ch2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tab Completion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you press tab after starting a variable name, it will suggest autofill options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "an_apple = 27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "an_example = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "an"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you create an object, you can use the tab key to see suggested methods or attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use tab to see suggestions for modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also tab complete anything that looks like a filename based on what is available in your filesystem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introspection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a question mark before or after a variable displays general information about the object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "b?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_numbers(a, b):\n",
    "    \"\"\"\n",
    "    Add two numbers together\n",
    "    Returns\n",
    "    --------\n",
    "    the_sum : type of arguments\n",
    "    \"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_numbers?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using ?? instead of ? will show the source code if possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_numbers??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The %run Command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any file can be run as a Python program inside the notebook by using %run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I didn't write this program so it won't run, but if it was saved in this directory it would run inline\n",
    "%run ipython_script_test.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This runs on an empty namespace (no imports or variables defined) and behaves just like running it on the command line as `python script.py`. You can run the script with access to the variables in the IPython namespace by using `%run -i` instead of `%run`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib Integration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the %matplotlib magic function to configure its integration with Jupyter notebook. You must do this for plots to appear in the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x112de4908>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109e73cf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "plt.plot(np.random.randn(50).cumsum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Everything is an object\n",
    "Python has a consistent object-oriented model. Everything (number, string, data structure, etc.) exists within the Python interpreter in its own \"box\" or Python object. Objects have an associated type and internal data.\n",
    "\n",
    "Objects also have attached functions, known as methods, that can access the objects internal contents. They can be called on the object like so:\n",
    "\n",
    "`obj.some_method(a,b,c)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has variables, which create references to objects. This assignment is also known as _binding_ and variable names that are assigned may be called _bound variables_\n",
    "\n",
    "For example, if we create a variable that is a list of integers, the variable references the list object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we create another variable that references the previous variable, it does not copy and store the contents. It references the same list object as the other variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This allows changes to the object to reflect across all related variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python is strongly typed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type information in Python is stored in the object itself. Python is considered _strongly typed_, so all objects have a specific type (or _class_). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-5c0ea535e581>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Objects have a defined type and the types have certain behaviors.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;34m'5'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "# Objects have a defined type and the types have certain behaviors.\n",
    "'5' + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can check that an object is a given type using the isinstance function\n",
    "a = 5\n",
    "isinstance(a,int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# isinstance can also run on a tuple of types\n",
    "a = 5; b = 4.5\n",
    "isinstance(a, (int, float))\n",
    "isinstance(b, (int, float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attributes and Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attributes are other Python objects stored \"inside\" an object, methods are functions that are associated with an object that can access its internal data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'foo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use tab to see methods\n",
    "a."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.split>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Attributes/methods can be accessed by name with the getattr function\n",
    "getattr(a, 'split')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Duck typing (if it walks like a duck) can be used to validate if an object has certain methods or behavior. In the example below, you can verify an object is iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isiterable(obj):\n",
    "    try:\n",
    "        iter(obj)\n",
    "        return True\n",
    "    except TypeError:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isiterable('a string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isiterable([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isiterable(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python _modules_ are files with .py extensions that contain Python code. Here is an example module called some_module.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PI = 3.14159\n",
    "\n",
    "def f(x):\n",
    "    return x + 2\n",
    "\n",
    "def g(a,b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the variables or functions in that module, you can use _import_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import some_module\n",
    "# use functions provided by that module\n",
    "result = some_module.f(5)\n",
    "# use variables provided by that module\n",
    "pi = some_module.PI\n",
    "\n",
    "# import specific parts of the module\n",
    "from some_module import f, g, PI\n",
    "result = g(5, PI)\n",
    "\n",
    "# use keywords to give imports different variable names\n",
    "import some_module as sm\n",
    "from some_module import PI as pi, g as gf\n",
    "\n",
    "r1 = sm.f(pi)\n",
    "r2 = gf(6, pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single value types (numerical data, strings, boolean values) are sometimes called _scalar types_ and are referred to as scalars. Scalars include: \n",
    "- None\n",
    "- str (string)\n",
    "- bytes (raw ASCII)\n",
    "- float (floating-point numbers)\n",
    "- bool (True or False)\n",
    "- int (precision numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Formatting\n",
    "String objects have a `format` method that can be used to add formatted arguments into the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "template = '{0:.2f} {1:s} are worth US${2:d}'\n",
    "# the first argument is a floating-point number with two decimal places\n",
    "# the second argument is a string\n",
    "# the third argument is an exact integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.56 Argentine Pesos are worth US$1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template.format(4.5560, 'Argentine Pesos', 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dates and times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built in `datetime` modlue provides `datetime`, `date`, and `time` types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, date, time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = datetime(2011, 10, 29, 20, 30, 21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2011, 10, 29)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.date()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.time(20, 30, 21)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 10, 29, 20, 0)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can replace time fields in a series of datetimes with zero\n",
    "dt.replace(minute=0, second= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the difference of two datetime objects is a datetime.timedelta type\n",
    "dt2 = datetime(2011, 11, 15, 22, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = dt2 - dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(17, 7179)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# delta will return with days and seconds in the output\n",
    "delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(delta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programming languages have control flow, such as conditional logic and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if, elif, else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if statements check if a condition is true and then evaluates the code if it is\n",
    "if x < 0:\n",
    "    print(\"It's negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if statements can be followed by elif blocks or a catch all else block\n",
    "if x <0:\n",
    "    print('It\\'s negative'')\n",
    "elif x == 0:\n",
    "    print('Equal to zero')\n",
    "elif 0 < x < 5:\n",
    "    print('Positive but smaller than 5')\n",
    "else:\n",
    "    print('Positive and larger than or equal to 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for loops iterate over a collection lists, tuples, etc.) or an iterator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# syntax of a for loop is as follows\n",
    "for value in collection:\n",
    "    # do something with the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can skip the remainder of the block with the continue keyword\n",
    "sequence = [1, 2, None, 4, None, 5]\n",
    "total = 0\n",
    "for value in sequence:\n",
    "    if value is None:\n",
    "        continue\n",
    "    total += value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loops can be exited with the break keyword. This will terminate the innermost for loop, outer loops will continue to run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence = [1, 2, 0, 4, 6, 5, 2, 1]\n",
    "total_until_5 = 0\n",
    "for value in sequence:\n",
    "    if value == 5:\n",
    "        break\n",
    "    total_until_5 += value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you acn unpack sequences (tuples or lists) into variables using a for loop\n",
    "for a, b, c in iterator:\n",
    "    # do something"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### while loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A while loop specifies a condition and a block a code that executes until the condition evaluates to False or the loop is ended with a break."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 256\n",
    "total - 0\n",
    "while x > 0:\n",
    "    if total > 500:\n",
    "        break\n",
    "    total += x\n",
    "    x = x // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pass is the \"no-op\" statement in Python that is used when no action is meant to be taken; only needed because Python requires whitespace to delimit blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x <0:\n",
    "    print('negative!')\n",
    "elif x == 0:\n",
    "    # TODO: put something smart here\n",
    "    pass\n",
    "else:\n",
    "    print('positive!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### range"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "range returns an iterator that yields a sequence of evenly spaced integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can use a third parameter to specify the step\n",
    "list(range(0, 20, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5, 0 , -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range produces integers up to but not including the endpoint\n",
    "seq = [1, 2, 3, 4]\n",
    "for i in range(len(seq)):\n",
    "    val = seq[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2333316668\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "for i in range(100000):\n",
    "    # % is the modulo operator\n",
    "    if i % 3 == 0 or i % 5 ==0:\n",
    "        sum += i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ternary expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ternary expressions allow you to combine if-else blocks that produce a value into a single line or expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if condition:\n",
    "    value = true expression\n",
    "else:\n",
    "    value = false expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Non-negative'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a more concrete example\n",
    "x = 5 \n",
    "'Non-negative' if x >= 0 else 'Negative'"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}