content/Introduction_to_Programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to programming\n",
    "_Written by Luke Chang_\n",
    "\n",
    "In this notebook we will begin to learn how to use Python.  There are many different ways to install Python, but we recommend starting using Anaconda which is preconfigured for scientific computing.  Start with installing [Python 3.7](https://www.anaconda.com/distribution/).  For those who prefer a more configurable IDE, [Pycharm](https://www.jetbrains.com/pycharm/) is a nice option.  Python is a modular interpreted language with an intuitive minimal syntax that is quickly becoming one of the most popular languages for [conducting research](http://www.talyarkoni.org/blog/2013/11/18/the-homogenization-of-scientific-computing-or-why-python-is-steadily-eating-other-languages-lunch/).  You can use python for [stimulus presentation](http://www.psychopy.org/), [data analysis](http://statsmodels.sourceforge.net/), [machine-learning](http://scikit-learn.org/stable/), [scraping data](https://www.crummy.com/software/BeautifulSoup/), creating websites with [flask](http://flask.pocoo.org/) or [django](https://www.djangoproject.com/), or [neuroimaging data analysis](http://nipy.org/).\n",
    "\n",
    "There are lots of free useful resources to learn how to use python and various modules.  See [Jeremy Manning's](https://github.com/ContextLab/cs-for-psych) or [Yaroslav Halchenko's](https://github.com/dartmouth-pbs/psyc161) excellent Dartmouth courses.  [Codeacademy](https://www.codecademy.com/) is a great interactive tutorial.  [Stack Overflow](http://stackoverflow.com/) is an incredibly useful resource for asking specific questions and seeing responses to others that have been rated by the development community. \n",
    "\n",
    "![](../images/programming/programming_growth.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebooks\n",
    "We will primarily be using [Jupyter Notebooks](http://jupyter.org/) to interface with Python.  A Jupyter notebook consists of **cells**. The two main types of cells you will use are code cells and markdown cells.\n",
    "\n",
    "A **_code cell_** contains actual code that you want to run. You can specify a cell as a code cell using the pulldown menu in the toolbar in your Jupyter notebook. Otherwise, you can can hit esc and then y (denoted \"esc, y\") while a cell is selected to specify that it is a code cell. Note that you will have to hit enter after doing this to start editing it.\n",
    "If you want to execute the code in a code cell, hit \"shift + enter.\" Note that code cells are executed in the order you execute them. That is to say, the ordering of the cells for which you hit \"shift + enter\" is the order in which the code is executed. If you did not explicitly execute a cell early in the document, its results are now known to the Python interpreter.\n",
    "\n",
    "**_Markdown cells_** contain text. The text is written in markdown, a lightweight markup language. You can read about its syntax [here](http://daringfireball.net/projects/markdown/syntax). Note that you can also insert HTML into markdown cells, and this will be rendered properly. As you are typing the contents of these cells, the results appear as text. Hitting \"shift + enter\" renders the text in the formatting you specify.  You can specify a cell as being a markdown cell in the Jupyter toolbar, or by hitting \"esc, m\" in the cell. Again, you have to hit enter after using the quick keys to bring the cell into edit mode.\n",
    "\n",
    "In general, when you want to add a new cell, you can use the \"Insert\" pulldown menu from the Jupyter toolbar. The shortcut to insert a cell below is \"esc, b\" and to insert a cell above is \"esc, a.\" Alternatively, you can execute a cell and automatically add a new one below it by hitting \"alt + enter.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Package Management\n",
    "Package managment in Python has been dramatically improving.  Anaconda has it's own package manager called 'conda'.  Use this if you would like to install a new module as it is optimized to work with anaconda. \n",
    "\n",
    "```\n",
    "!conda install *package*\n",
    "```\n",
    "\n",
    "However, sometimes conda doesn't have a particular package.  In this case use the default python package manager called 'pip'. \n",
    "\n",
    "These commands can be run in your unix terminal or you can send them to the shell from a Jupyter notebook by starting the line with ```!```\n",
    "\n",
    "It is easy to get help on how to use the package managers\n",
    "\n",
    "```\n",
    "!pip help install\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip help install"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip list --outdated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install setuptools --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Python is a dynamically typed language, which means that you can easily change the datatype associated with a variable. There are several built-in datatypes that are good to be aware of.\n",
    "\n",
    "* Built-in\n",
    "  * Numeric types:\n",
    "    * **int**, **float**, **long**, complex\n",
    "  * String: **str** \n",
    "  * Boolean: **bool**\n",
    "    * True / False\n",
    "  * **NoneType**\n",
    "* User defined\n",
    "\n",
    "* Use the type() function to find the type for a value or variable\n",
    "\n",
    "* Data can be converted using cast commands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:30:38.551243Z",
     "start_time": "2020-03-29T21:30:38.545411Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# Integer\n",
    "a = 1\n",
    "print(type(a))\n",
    "\n",
    "# Float\n",
    "b = 1.0\n",
    "print(type(b))\n",
    "\n",
    "# String\n",
    "c = 'hello'\n",
    "print(type(c))\n",
    "\n",
    "# Boolean\n",
    "d = True\n",
    "print(type(d))\n",
    "\n",
    "# None\n",
    "e = None\n",
    "print(type(e))\n",
    "\n",
    "# Cast integer to string\n",
    "print(type(str(a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math Operators\n",
    "* +, -, *, and /\n",
    "* Exponentiation **\n",
    "* Modulo %\n",
    "\n",
    "* Note that division with integers in Python 2.7 automatically rounds, which may not be intended.  It is recommended to import the division module from python3 `from __future__ import division`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:31:18.857194Z",
     "start_time": "2020-03-29T21:31:18.853110Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "4\n",
      "8\n",
      "16\n",
      "4\n",
      "0.4444444444444444\n"
     ]
    }
   ],
   "source": [
    "# Addition\n",
    "a = 2 + 7\n",
    "print(a)\n",
    "\n",
    "# Subtraction\n",
    "b = a - 5\n",
    "print(b)\n",
    "\n",
    "# Multiplication\n",
    "print(b*2)\n",
    "\n",
    "# Exponentiation\n",
    "print(b**2)\n",
    "\n",
    "# Modulo\n",
    "print(4%9)\n",
    "\n",
    "# Division\n",
    "print(4/9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String Operators\n",
    "* Some of the arithmetic operators also have meaning for strings. E.g. for string concatenation use `+` sign\n",
    "* String repetition: Use `*` sign with a number of repetitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:31:26.202011Z",
     "start_time": "2020-03-29T21:31:26.199008Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n",
      "HelloHelloHelloHelloHello\n"
     ]
    }
   ],
   "source": [
    "# Combine string\n",
    "a = 'Hello'\n",
    "b = 'World'\n",
    "print(a + b)\n",
    "\n",
    "# Repeat String\n",
    "print(a*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical Operators\n",
    "Perform logical comparison and return Boolean value\n",
    "\n",
    "```python\n",
    "x == y # x is equal to y\n",
    "x != y # x is not equal to y\n",
    "x > y # x is greater than y\n",
    "x < y # x is less than y\n",
    "x >= y # x is greater than or equal to y \n",
    "x <= y # x is less than or equal to y\n",
    "```\n",
    "\n",
    "|  X    | not X  | \n",
    "|-------|--------|\n",
    "| True  | False  | \n",
    "| False | True   | \n",
    "\n",
    "|  X   | Y    | X AND Y | X OR Y | \n",
    "|------|------|---------|--------|\n",
    "|True  | True | True  | True   | \n",
    "|True  | False| False | True   | \n",
    "|False | True | False | True   | \n",
    "|False | False| False | False  | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:31:51.575225Z",
     "start_time": "2020-03-29T21:31:51.570825Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Works for string\n",
    "a = 'hello'\n",
    "b = 'world'\n",
    "c = 'Hello'\n",
    "print(a==b)\n",
    "print(a==c)\n",
    "print(a!=b)\n",
    "\n",
    "# Works for numeric\n",
    "d = 5\n",
    "e = 8\n",
    "print(d < e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Logic (if...)\n",
    "Unlike most other languages, Python uses tab formatting rather than closing conditional statements (e.g., end).\n",
    "\n",
    "* Syntax:\n",
    "\n",
    "```python \n",
    "if condition: \n",
    "    do something\n",
    "```\n",
    "\n",
    "* Implicit conversion of the value to bool() happens if `condition` is of a different type than **bool**, thus all of the following should work:\n",
    "\n",
    "```python\n",
    "if condition:\n",
    "    do_something\n",
    "elif condition:\n",
    "    do_alternative1\n",
    "else:\n",
    "    do_otherwise # often reserved to report an error\n",
    "                 # after a long list of options\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:32:06.906115Z",
     "start_time": "2020-03-29T21:32:06.902388Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n is non-0\n",
      "n is not None\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "\n",
    "if n:\n",
    "    print(\"n is non-0\")\n",
    "\n",
    "if n is None:\n",
    "    print(\"n is None\")\n",
    "    \n",
    "if n is not None:\n",
    "    print(\"n is not None\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "* **for** loop is probably the most popular loop construct in Python:\n",
    "\n",
    "```python\n",
    "for target in sequence:\n",
    "    do_statements\n",
    "```\n",
    "\n",
    "* However, it's also possible to use a **while** loop to repeat statements while `condition` remains True:\n",
    "\n",
    "```python\n",
    "while condition do:\n",
    "    do_statements\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:32:18.200091Z",
     "start_time": "2020-03-29T21:32:18.194818Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "g\n",
      "o\n",
      "i\n",
      "n\n",
      "g\n",
      " \n",
      "t\n",
      "o\n",
      " \n",
      "m\n",
      "a\n",
      "k\n",
      "e\n",
      " \n",
      "c\n",
      "o\n",
      "n\n",
      "d\n",
      "u\n",
      "c\n",
      "t\n",
      "i\n",
      "n\n",
      "g\n",
      " \n",
      "r\n",
      "e\n",
      "s\n",
      "e\n",
      "a\n",
      "r\n",
      "c\n",
      "h\n",
      " \n",
      "e\n",
      "a\n",
      "s\n",
      "i\n",
      "e\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "string = \"Python is going to make conducting research easier\"\n",
    "for c in string:\n",
    "    print(c)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-07T14:43:12.927002Z",
     "start_time": "2020-04-07T14:43:12.922886Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "1 1\n",
      "2 3\n",
      "3 6\n",
      "4 10\n",
      "5 15\n",
      "6 21\n",
      "7 28\n",
      "8 36\n",
      "9 45\n",
      "Exited with x==10\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "end = 10\n",
    "\n",
    "csum = 0\n",
    "while x < end:\n",
    "    csum += x\n",
    "    print(x, csum)\n",
    "    x += 1\n",
    "print(f\"Exited with x=={x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "A **function** is a named sequence of statements that performs a computation.  You define the function by giving it a name, specify a sequence of statements, and optionally values to return.  Later, you can “call” the function by name. \n",
    "```python\n",
    "def make_upper_case(text):\n",
    "    return (text.upper())\n",
    "```\n",
    "* The expression in the parenthesis is the **argument**. \n",
    "* It is common to say that a function **“takes” an argument** and **“returns” a result**.\n",
    "* The result is called the **return value**.\n",
    "\n",
    "The first line of the function definition is called the **header**; the rest is called the **body**.\n",
    "\n",
    "The header has to end with a colon and the body has to be indented.\n",
    "It is a common practice to use 4 spaces for indentation, and to avoid mixing with tabs.\n",
    "\n",
    "Function body in Python ends whenever statement begins at the original level of indentation.  There is no **end** or **fed** or any other identify to signal the end of function.  Indentation is part of the the language syntax in Python, making it more readable and less cluttered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:34:41.997850Z",
     "start_time": "2020-03-29T21:34:41.994452Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PYTHON IS GOING TO MAKE CONDUCTING RESEARCH EASIER\n"
     ]
    }
   ],
   "source": [
    "def make_upper_case(text):\n",
    "    return (text.upper())\n",
    "\n",
    "string = \"Python is going to make conducting research easier\"\n",
    "\n",
    "print(make_upper_case(string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Containers\n",
    "There are 4 main types of builtin containers for storing data in Python:\n",
    "* list\n",
    "* tuple\n",
    "* dict\n",
    "* set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "In Python, a list is a mutable sequence of values.  Mutable means that we can change separate entries within a list. For a more in depth tutorial on lists look [here](http://nbviewer.jupyter.org/github/dartmouth-pbs/psyc161/blob/master/classes/02d-Python-Fundamentals-Containers-Lists.ipynb)\n",
    "\n",
    "* Each value in the list is an element or item\n",
    "* Elements can be any Python data type\n",
    "* Lists can mix data types\n",
    "\n",
    "* Lists are initialized with ```[]``` or ```list()```\n",
    "```python\n",
    "l = [1,2,3]\n",
    "```\n",
    "* \n",
    "Elements within a list are indexed (**starting with 0**)\n",
    "```python\n",
    "l[0]\n",
    "```\n",
    "\n",
    "* \n",
    "Elements can be nested lists\n",
    "```python\n",
    "nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "```\n",
    "\n",
    "* \n",
    "Lists can be *sliced*.\n",
    "```python\n",
    "l[start:stop:stride]\n",
    "```\n",
    "\n",
    "* Like all python containers, lists have many useful methods that can be applied\n",
    "```python\n",
    "a.insert(index,new element)\n",
    "a.append(element to add at end)\n",
    "len(a)\n",
    "```\n",
    "\n",
    "* \n",
    "List comprehension is a *Very* powerful technique allowing for efficient construction of new lists.\n",
    "```python\n",
    "[a for a in l]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:35:32.077135Z",
     "start_time": "2019-04-12T02:35:32.067785Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lists\n",
      "['are', 'arrays']\n",
      "['lists', 'are', 'python', 'arrays', '.']\n",
      "5\n",
      "['LISTS', 'ARE', 'PYTHON', 'ARRAYS', '.']\n"
     ]
    }
   ],
   "source": [
    "# Indexing and Slicing\n",
    "a = ['lists','are','arrays']\n",
    "print(a[0])\n",
    "print(a[1:3])\n",
    "\n",
    "# List methods\n",
    "a.insert(2,'python')\n",
    "a.append('.')\n",
    "print(a)\n",
    "print(len(a))\n",
    "\n",
    "# List Comprehension\n",
    "print([x.upper() for x in a])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "* In Python, a dictionary (or `dict`) is mapping between a set of\n",
    "indices (**keys**) and a set of **values**\n",
    "\n",
    "* The items in a dictionary are key-value pairs\n",
    "\n",
    "* Keys can be any Python data type\n",
    "\n",
    "* Dictionaries are unordered\n",
    "\n",
    "* Here is a more indepth tutorial on [dictionaries](http://nbviewer.jupyter.org/github/dartmouth-pbs/psyc161/blob/master/classes/03c-Python-Fundamentals-Containers-Dicts.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:35:34.447617Z",
     "start_time": "2019-04-12T02:35:34.441018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 'uno'}\n",
      "{'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
      "dict_keys(['one', 'two', 'three'])\n",
      "dict_values(['uno', 'dos', 'tres'])\n"
     ]
    }
   ],
   "source": [
    "# Dictionaries\n",
    "eng2sp = {}\n",
    "eng2sp['one'] = 'uno'\n",
    "print(eng2sp)\n",
    "\n",
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "print(eng2sp)\n",
    "\n",
    "print(eng2sp.keys())\n",
    "print(eng2sp.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "In Python, a **tuple** is an immutable sequence of values, meaning they can't be changed\n",
    "\n",
    "* Each value in the tuple is an element or item\n",
    "\n",
    "* Elements can be any Python data type\n",
    "\n",
    "* Tuples can mix data types\n",
    "\n",
    "* Elements can be nested tuples\n",
    "\n",
    "* **Essentially tuples are immutable lists**\n",
    "\n",
    "Here is a nice tutorial on [tuples](http://nbviewer.jupyter.org/github/dartmouth-pbs/psyc161/blob/master/classes/03b-Python-Fundamentals-Containers-Tuples.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:35:36.663925Z",
     "start_time": "2019-04-12T02:35:36.659607Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "numbers = (1, 2, 3, 4)\n",
    "print(numbers)\n",
    "\n",
    "t2 = 1, 2\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sets\n",
    "In Python, a `set` is an efficient storage for \"membership\" checking\n",
    "\n",
    "* `set` is like a `dict` but only with keys and without values\n",
    "\n",
    "* a `set` can also perform set operations (e.g., union intersection)\n",
    "\n",
    "* Here is more info on [sets](http://nbviewer.jupyter.org/github/dartmouth-pbs/psyc161/blob/master/classes/03d-Python-Fundamentals-Containers-Sets.ipynb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:35:38.353483Z",
     "start_time": "2019-04-12T02:35:38.347187Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 'mom', 10, 'dad'}\n",
      "{2, 3}\n",
      "{1, 'mom', 'dad'}\n"
     ]
    }
   ],
   "source": [
    "# Union\n",
    "print({1, 2, 3, 'mom', 'dad'} | {2, 3, 10})\n",
    "\n",
    "# Intersection\n",
    "print({1, 2, 3, 'mom', 'dad'} & {2, 3, 10})\n",
    "\n",
    "# Difference\n",
    "print({1, 2, 3, 'mom', 'dad'} - {2, 3, 10})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "A *Module* is a python file that contains a collection of related definitions. Python has *hundreds* of standard modules.  These are organized into what is known as the [Python Standard Library](http://docs.python.org/library/).  You can also create and use your own modules.  To use functionality from a module, you first have to import the entire module or parts of it into your namespace\n",
    "\n",
    "* To import the entire module, use \n",
    "\n",
    "```python\n",
    "import module_name\n",
    "```\n",
    "\n",
    "* You can also import a module using a specific name \n",
    "\n",
    "```python\n",
    "import module_name as new_module_name\n",
    "```\n",
    "\n",
    "* To import specific definitions (e.g. functions, variables, etc) from the module into your local namespace, use\n",
    "\n",
    "```python\n",
    "from module_name import name1, name2\n",
    "```\n",
    "   which will make those available directly in your `namespace`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:36:21.728999Z",
     "start_time": "2020-03-29T21:36:21.726556Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from glob import glob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here let's try and get the path of the current working directory using functions from the `os` module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:36:23.389224Z",
     "start_time": "2020-03-29T21:36:23.379533Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/lukechang/Dropbox/Dartbrains/Notebooks'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.abspath(os.path.curdir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like we are currently in the notebooks folder of the github repository.  Let's use glob, a pattern matching function, to list all of the csv files in the Data folder.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-29T21:36:24.586596Z",
     "start_time": "2020-03-29T21:36:24.581548Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "data_file_list = glob(os.path.join('../..','Data','*csv'))\n",
    "print(data_file_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives us a list of the files including the relative path from the current directory.  What if we wanted just the filenames?  There are several different ways to do this.  First, we can use the the `os.path.basename` function.  We loop over every file, grab the base file name and then append it to a new list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:36:36.230636Z",
     "start_time": "2019-04-12T02:36:36.226015Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['salary_exercise.csv', 'salary.csv']\n"
     ]
    }
   ],
   "source": [
    "file_list = []\n",
    "for f in data_file_list:\n",
    "    file_list.append(os.path.basename(f))\n",
    "\n",
    "print(file_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we could loop over all files and split on the `/` character.  This will create a new list where each element is whatever characters are separated by the splitting character.  We can then take the last element of each list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:36:37.815481Z",
     "start_time": "2019-04-12T02:36:37.811090Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['salary_exercise.csv', 'salary.csv']\n"
     ]
    }
   ],
   "source": [
    "file_list = []\n",
    "for f in data_file_list:\n",
    "    file_list.append(f.split('/')[-1])\n",
    "\n",
    "print(file_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also sometimes even cleaner to do this as a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-12T02:36:39.298279Z",
     "start_time": "2019-04-12T02:36:39.294322Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['salary_exercise.csv', 'salary.csv']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[os.path.basename(x) for x in data_file_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find Even Numbers\n",
    "Let’s say I give you a list saved in a variable: a = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]. Make a new list that has only the even elements of this list in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-02T19:15:39.545870Z",
     "start_time": "2019-04-02T19:15:39.540008Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find Maximal Range\n",
    "Given an array length 1 or more of ints, return the difference between the largest and smallest values in the array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-02T19:19:03.208318Z",
     "start_time": "2019-04-02T19:19:03.204234Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Duplicated Numbers\n",
    "Find the numbers in list a that are also in list b\n",
    "\n",
    "a = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]\n",
    "\n",
    "b = [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-02T19:25:09.619091Z",
     "start_time": "2019-04-02T19:25:09.614541Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Speeding Ticket Fine\n",
    "You are driving a little too fast on the highway, and a police officer stops you. Write a function that takes the speed as an input and returns the fine.\n",
    "\n",
    "\n",
    "If speed is 60 or less, the result is `$0`. If speed is between 61 and 80 inclusive, the result is `$100`. If speed is 81 or more, the result is `$500`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-02T19:29:04.436691Z",
     "start_time": "2019-04-02T19:29:04.432539Z"
    }
   },
   "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.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}