Intro to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro to Python\n",
    "In this notebook, we will introduce basic Python programming to get a beginner up and running (and more).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables, Types, and more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "new_string = 'Hello'\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# Concatentation\n",
    "newer_string = 'World!'\n",
    "another_string = new_string + ' ' + newer_string\n",
    "print(another_string)\n",
    "print(new_string, newer_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: Here is how to substitute into a string\n"
     ]
    }
   ],
   "source": [
    "# Substitution, by index\n",
    "sentence = 'Here is how to {0} into a {1}'\n",
    "action = 'substitute'\n",
    "thing = 'string'\n",
    "print('Result:', sentence.format(action, thing))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: Keyword substitute for strings\n"
     ]
    }
   ],
   "source": [
    "# Substitution, by keyword\n",
    "sentence = 'Keyword {_action} for {_thing}s'\n",
    "print('Result:', sentence.format(_action=action, _thing=thing))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 10\n",
      "13\n",
      "0.05\n"
     ]
    }
   ],
   "source": [
    "# Variables\n",
    "a, b = 1, 2\n",
    "c = 10\n",
    "print(a, b, c)\n",
    "print(a + b + c)\n",
    "print(a / b / c) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# Increment, etc\n",
    "a += 1\n",
    "print(a / b)\n",
    "b -= 1\n",
    "print(a / b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n",
      "<class 'function'>\n"
     ]
    }
   ],
   "source": [
    "# Types\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(a/b))\n",
    "print(type(True))\n",
    "print(type(None))\n",
    "print(type(lambda x: x+x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'ford', 'skoda']\n",
    "print(len(cars))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bmw\n",
      "ford\n"
     ]
    }
   ],
   "source": [
    "# Get elements by index\n",
    "print(cars[0])\n",
    "print(cars[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bmw', 'ford', 'skoda', 'kia']\n"
     ]
    }
   ],
   "source": [
    "# Add to a list\n",
    "cars.append('kia')\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kia'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get last element\n",
    "cars[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bmw', 'ford', 'skoda', 'kia']\n",
      "['ford', 'skoda']\n",
      "['ford', 'skoda', 'kia']\n",
      "['bmw', 'ford', 'skoda']\n"
     ]
    }
   ],
   "source": [
    "# List Slices\n",
    "print(cars[:])\n",
    "print(cars[1:3])\n",
    "print(cars[1:]) # note, includes index 1\n",
    "print(cars[:3]) # note, does not include index 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Copy a list, versus reference a list\n",
    "ref_cars = cars\n",
    "copy_cars = cars[:]\n",
    "print(ref_cars is cars) # two variables pointing to the same object\n",
    "print(copy_cars is cars) # two different instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# Mix types in lists\n",
    "stuff = [1, 0.5, 'Hello', True]\n",
    "for s in stuff:\n",
    "    print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sizes:\n",
      "3\n",
      "5\n",
      "5\n",
      "6\n",
      "\n",
      "Types:\n",
      "<class 'list'>\n",
      "<class 'list'>\n",
      "<class 'int'>\n",
      "\n",
      "Elements:\n",
      "[11, 12, 13, 14, 15]\n",
      "11\n",
      "22\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "# Multi dimensional lists\n",
    "d1 = [11,12,13,14,15]\n",
    "d2 = [21,22,23,24,25]\n",
    "d3 = [31,32,33,34,35,36]\n",
    "d = [d1,d2,d3]\n",
    "\n",
    "print('Sizes:')\n",
    "print(len(d))\n",
    "print(len(d[0]))\n",
    "print(len(d[1]))\n",
    "print(len(d[2]))\n",
    "\n",
    "print('\\nTypes:')\n",
    "print(type(d))\n",
    "print(type(d[0]))\n",
    "print(type(d[0][0]))\n",
    "\n",
    "print('\\nElements:')\n",
    "print(d[0])\n",
    "print(d[0][0])\n",
    "print(d[1][1])\n",
    "print(d[-1][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boats': ['campion', 'seadoo'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': None}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "vehicles = {\n",
    "    'cars': cars,\n",
    "    'trucks': ['toyota', 'gmc'],\n",
    "    'boats': ['campion', 'seadoo'],\n",
    "    'flying cars': None\n",
    "}\n",
    "print(vehicles) # note, dicts are not ordered\n",
    "print(type(vehicles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['campion', 'seadoo']\n",
      "['campion', 'seadoo']\n"
     ]
    }
   ],
   "source": [
    "# Get values from keys\n",
    "print(vehicles['boats'])\n",
    "# or\n",
    "print(vehicles.get('boats'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boats': ['campion', 'seadoo'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': 'Coming soon...'}\n"
     ]
    }
   ],
   "source": [
    "# Assign to existing key\n",
    "vehicles['flying cars'] = 'Coming soon...'\n",
    "print(vehicles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'boats': ['campion', 'seadoo'], 'planes': ['boeing', 'airbus'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': 'Coming soon...'}\n"
     ]
    }
   ],
   "source": [
    "# Add new key:value pairs\n",
    "vehicles['planes'] = ['boeing', 'airbus']\n",
    "print(vehicles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['boats', 'planes', 'cars', 'trucks', 'flying cars'])\n"
     ]
    }
   ],
   "source": [
    "# Get all keys of the dictionary\n",
    "print(vehicles.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([['campion', 'seadoo'], ['boeing', 'airbus'], ['bmw', 'ford', 'skoda', 'kia'], ['toyota', 'gmc'], 'Coming soon...'])\n"
     ]
    }
   ],
   "source": [
    "# Get all values of the dictionary\n",
    "print(vehicles.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "\n",
    "# Equals\n",
    "print(x == y)\n",
    "print(x + 1 == y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Not Equal\n",
    "print(x != y)\n",
    "print(x + 1 != y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Greater than\n",
    "print(x > y)\n",
    "print(x + 2 > y)\n",
    "print(x + 1 >= y) # or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Less than\n",
    "print(x < y)\n",
    "print(x + 2 < y)\n",
    "print(x + 1 <= y) # or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Logical Operators\n",
    "print(x <= 1 and y > 1)\n",
    "print(x == 2 or y == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Common String conditions\n",
    "claim = 'Python is the best!'\n",
    "\n",
    "print(claim == 'Python is the best!')\n",
    "print(claim == 'python is the best!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Starts or Ends with\n",
    "print(claim.startswith('Py'))\n",
    "print(claim.startswith('py'))\n",
    "print(claim.endswith('best!'))\n",
    "print(claim.endswith('Best!'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Contains\n",
    "print('Python' in claim)\n",
    "print('isthe' in claim)\n",
    "print('is the' in claim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Not conditions\n",
    "print(not True)\n",
    "print(not claim.startswith('Nope'))\n",
    "print('wrong' not in claim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If/Else statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bmw', 'ford', 'skoda', 'kia']\n"
     ]
    }
   ],
   "source": [
    "if len(cars) > 0:\n",
    "    print(cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No cars\n"
     ]
    }
   ],
   "source": [
    "if len(cars) > 4:\n",
    "    print(cars)\n",
    "else:\n",
    "    print('No cars')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cool!\n",
      "No Opinion.\n",
      "Cool!\n",
      "Meh...\n"
     ]
    }
   ],
   "source": [
    "# Chain Conditions\n",
    "for car in cars:\n",
    "    if car == 'bmw' or car == 'skoda':\n",
    "        print('Cool!')\n",
    "    elif car == 'kia':\n",
    "        print('Meh...')\n",
    "    else:\n",
    "        print('No Opinion.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bmw\n",
      "ford\n",
      "skoda\n",
      "kia\n"
     ]
    }
   ],
   "source": [
    "# For Loop\n",
    "for car in cars: # iterates through cars\n",
    "    print(car)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# While Loop\n",
    "counter = 5\n",
    "while counter > 0:\n",
    "    print(counter)\n",
    "    counter -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key boats has a value of ['campion', 'seadoo']\n",
      "Key planes has a value of ['boeing', 'airbus']\n",
      "Key cars has a value of ['bmw', 'ford', 'skoda', 'kia']\n",
      "Key trucks has a value of ['toyota', 'gmc']\n",
      "Key flying cars has a value of Coming soon...\n"
     ]
    }
   ],
   "source": [
    "# Example with dictionary\n",
    "for key, value in vehicles.items():\n",
    "    print('Key {0} has a value of {1}'.format(key, value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# Basic with positional arguments\n",
    "def myfunc(x, y):\n",
    "    return x + y\n",
    "\n",
    "print(myfunc(1, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "0.5\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Using keyword args\n",
    "def myfunc2(x=None, y=None):\n",
    "    if x and y:\n",
    "        return x / y\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "print(myfunc2())\n",
    "print(myfunc2(1, 2)) # positional\n",
    "print(myfunc2(y=1, x=2)) # keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kwargs: {}\n",
      "None\n",
      "Kwargs: {'x': 1, 'y': 1}\n",
      "2\n",
      "Kwargs: {'z': 1, 'w': 1}\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Using only keyword args\n",
    "def myfunc3(**kwargs):\n",
    "    print('Kwargs:', kwargs)\n",
    "    if 'x' in kwargs.keys() and 'y' in kwargs.keys():\n",
    "        return kwargs.get('x') + kwargs.get('y')\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "print(myfunc3())\n",
    "print(myfunc3(x=1, y=1))\n",
    "print(myfunc3(z=1, w=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "darwin\n"
     ]
    }
   ],
   "source": [
    "# import a library\n",
    "import sys\n",
    "print(sys.platform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seconds from epoch: 1488308232.22233\n"
     ]
    }
   ],
   "source": [
    "# import a module/function/class of a library\n",
    "from time import time\n",
    "print('Seconds from epoch:', time())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Working Directory /Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop\n"
     ]
    }
   ],
   "source": [
    "# The os library is used for most filesystem interactions, regardless of OS.\n",
    "import os\n",
    "cur_dir = os.getcwd()\n",
    "print('Current Working Directory', cur_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'README.md', 'utils']\n"
     ]
    }
   ],
   "source": [
    "# List contents of the directory\n",
    "contents = os.listdir(cur_dir)\n",
    "print(contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is file: .DS_Store\n",
      "Is dir: .git\n",
      "Is file: .gitignore\n",
      "Is dir: .ipynb_checkpoints\n",
      "Is dir: cheat sheets\n",
      "Is dir: images\n",
      "Is file: Install_Anaconda.md\n",
      "Is file: Intro to Python.ipynb\n",
      "Is dir: ls8\n",
      "Is file: README.md\n",
      "Is dir: utils\n"
     ]
    }
   ],
   "source": [
    "# Check if the element is a file or directory\n",
    "for content in contents:\n",
    "    if os.path.isfile(content):\n",
    "        print('Is file:', content)\n",
    "    elif os.path.isdir(content):\n",
    "        print('Is dir:', content)\n",
    "    else:\n",
    "        print('Unknown')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop/README.md\n"
     ]
    }
   ],
   "source": [
    "# Get the full path to a file, must be relative or absolute path\n",
    "full_path = os.path.realpath('README.md')\n",
    "print(full_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check if the file exists\n",
    "print(os.path.exists(full_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Python Workshop\n",
      "\n",
      "This repo contains materials for an entry level Python remote sensing workshop. Topics covered include:\n",
      "\n",
      "\n",
      "\n",
      "* Setup Anaconda and install GDAL\n",
      "\n",
      "* Introduce basic Python programming skills\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Open a file for reading\n",
    "myfile = open(full_path, 'r')\n",
    "for i in range(5):\n",
    "    print(myfile.readline())\n",
    "myfile.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop\n"
     ]
    }
   ],
   "source": [
    "# Get the directory from a path\n",
    "cur_dir = os.path.dirname(full_path)\n",
    "print(cur_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop/myfile.txt\n"
     ]
    }
   ],
   "source": [
    "# Create a new path to a file\n",
    "new_file = os.path.join(cur_dir, 'myfile.txt')\n",
    "print(new_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Current contents: ['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'myfile.txt', 'README.md', 'utils'] \n",
      "\n",
      "File Contents:\n",
      "\n",
      "Here is my new file.Cool right?\n",
      " Oops, forgot to add a new line.\n",
      "\n",
      "Current contents: ['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'README.md', 'utils'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Open a new file for writing\n",
    "myfile = open(new_file, 'w')\n",
    "myfile.write('Here is my new file.')\n",
    "myfile.write('Cool right?')\n",
    "myfile.write('\\n Oops, forgot to add a new line.')\n",
    "myfile.close()\n",
    "\n",
    "output_contents = lambda src_dir: print('\\nCurrent contents:', os.listdir(src_dir), '\\n')\n",
    "\n",
    "output_contents(cur_dir)\n",
    "\n",
    "# Alternate way of opening->reading_closing a file\n",
    "with open(new_file, 'r') as fr:\n",
    "    print('File Contents:\\n')\n",
    "    print(fr.read())\n",
    "\n",
    "# Delete (remove) the file\n",
    "os.remove(new_file)\n",
    "\n",
    "output_contents(cur_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Not covered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial has intentionally not covered things like Classes, Exceptions, or any other topics that are not necessary for the workshop. This is intended to keep things simple yet provide enough tools to work efficiently in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next Steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is meant as a crash course, not comprehensive by any means. If you are looking for more in depth Python training or tutorials, there are many resources online. Lot's of websites provide great programming language training, including Python. It is also recommended to buy a reference type Python book. There are many avaiable, including ones for geospatial work, for example: \n",
    "- [Python Geospatial Development](https://www.packtpub.com/application-development/python-geospatial-development-third-edition)\n",
    "- [Learning Geospatial Analysis with Python](https://www.packtpub.com/application-development/learning-geospatial-analysis-python)\n",
    "These books vary in learning level, and focus. The specific book is left to the user to find depending on their needs. \n",
    "\n",
    "Lastly, there is no programmer that does not depend on the internet for help with the most basic syntax to the most complicated algorithms. Don't waste too much time reading a book when a quick search on the internet will find what you need in under a second. Popular website for these types of answer is Stackoverflow or any of it's divisions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}