Notebooks/Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pre-Workshop Python Basics\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Description\n",
    "\n",
    "Python programming tools are now a standard feature within GIS software packages and allow GIS users to automate, speed up, and become more robust in their data management and analytic work. This **Pre-Workshop Module** is designed for GIS users who do not have much experience with Python programming to help them get up to speed on the basic Python concepts that will be covered in the Python for ArcGIS Workshop. This module should take about 1-2 hours to complete.\n",
    "\n",
    "*NOTE: Basic Python programming will not be covered in the Python for ArcGIS Workshop, so participants are expected to know some basic Python concepts such as syntax, variables, data types (strings, numbers, Booleans, lists, tuples, dictionaries, etc.) conditional statements, functions, and loops. These concepts are all covered below*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instructor\n",
    "\n",
    "<img style=\"float: left; padding: 20px\" alt=\"Image of James Whitacre\" src=\"https://bn1303files.storage.live.com/y4mKsXtKv_ISuvNNDwCpcxALPd6_VkUxuGpG-2bFWyPqHHyqfjPWpRWXCKuwh7xbpLhnueNL-JcqpZB_USWiYhb67-8coS_E9BkUNOGMZdVQ-rEBUCic8AxuZpKBxEKWaLW4LiQVjnAuqKDoPrClOkue_7VXv2BrSgDy_j7BoSOJKwnhQEcK6dtUV4wpk4TnjE9?width=300&height=300&cropmode=none\" width=\"300\" height=\"300\" />\n",
    "\n",
    "\n",
    "### James Whitacre\n",
    "\n",
    "**Chief of the GIS Services Division | Pennsylvania Game Commission**\n",
    "\n",
    "jawhitacre@pa.gov\n",
    "\n",
    "James Whitacre is Chief of the GIS Services Division of the Pennsylvania Game Commission where he leads, manages, and provides vision for the Agency’s geospatial and mapping program. Formerly, he was the GIS Research Scientist for the Carnegie Museum of Natural History where he managed the GIS Lab at Powdermill Nature Reserve, the Museum’s environmental research center, and supported museum staff and affiliated researchers with geospatial technologies and needs. Whitacre was also the GIS Manager from 2011 to 2014 at the Museum. Before returning to the Museum in 2018, Whitacre was the GIS Specialist for the Main Library at the University of Illinois at Urbana-Champaign where he provided GIS consultations for researchers and scholars, and taught GIS workshops to promote the use of GIS in research. Whitacre holds a Bachelor of Arts in Zoology from Ohio Wesleyan University and a Master of Science in Geography, concentrating on GIS and cartography, from Indiana University of Pennsylvania. Whitacre is currently a board member and Past President of PaMAGIC.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outline\n",
    "\n",
    "[**I. Data and Software Setup**](#I.-Data-and-Software-Setup)\n",
    "\n",
    "[**II. What is Python?**](#II.-What-is-Python?)\n",
    "\n",
    "[**III. Python Basics**](#III.-Python-Basics)\n",
    "* [Print Statement](#Print-Statement)\n",
    "* [Variables](#Variables)\n",
    "* [Basic Data Types](#Basic-Data-Types)\n",
    "    * [Strings](#Strings)\n",
    "    * [Numbers](#Numbers)\n",
    "    * [Booleans](#Booleans)\n",
    "    * [Lists](#Lists)\n",
    "    * [Tuples](#Tuples)\n",
    "    * [Dictionaries](#Dictionaries)\n",
    "* [Data Type Conversions](#Data-Type-Conversions)\n",
    "* [Simple Math with Python](#Simple-Math-with-Python)\n",
    "* [Python Basic Syntax](#Python-Basic-Syntax)\n",
    "* [Conditional Statements](#Conditional-Statements)\n",
    "* [Functions](#Functions)\n",
    "* [Loops](#Loops)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# I. Data and Software Setup\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing and Software Needs\n",
    "\n",
    "### 1. ArcGIS Pro 2.5.x+ or ArcGIS Desktop 10.4.x+ (Standard or Advanced preferred)\n",
    "\n",
    "* **<a href=\"https://pro.arcgis.com/en/pro-app/arcpy/get-started/pro-notebooks.htm\" target=\"_blank\">ArcGIS Notebooks</a>** will be used for practicing writing code\n",
    "    * Included with ArcGIS Pro 2.5+\n",
    "    * Optimal for ArcGIS and Python 3\n",
    "    * Easily run code directly in ArcGIS Pro\n",
    "\n",
    "### 2. Python Code Editor or IDE\n",
    "The workshop is designed to use any script editor or integrated development environment (IDE) and can be completed using any combination of the software included in the list below. The items in bold are the recommended applications for the workshop in order.\n",
    "\n",
    "\n",
    "* **<a href=\"https://jupyter.org/\" target=\"_blank\">Jupyter Notebook</a>**\n",
    "    * Installed with ArcGIS Pro 2.2+\n",
    "    * Optimal for Python 3\n",
    "    * Easily run code in the application\n",
    "\n",
    "\n",
    "* **<a href=\"https://code.visualstudio.com/\" target=\"_blank\">Visual Studio Code</a>**\n",
    "    * Great all purpose code and text editor...an essential application for coding in numerous languages!\n",
    "    * See <a href=\"https://code.visualstudio.com/docs/python/python-tutorial\" target=\"_blank\">Getting Started with Python in VS Code</a> for Python setup\n",
    "    * Requires some application savvy-ness to unleash full potential\n",
    "    * Not very easy to run code in the application\n",
    "\n",
    "\n",
    "* **<a href=\"https://notepad-plus-plus.org/\" target=\"_blank\">Notepad++</a>**\n",
    "    * Great all purpose text editor\n",
    "    * Highlights Python syntax so can be used to develop Python scripts\n",
    "    * Not very easy to run code in the application\n",
    "\n",
    "\n",
    "* <a href=\"https://docs.python.org/2/library/idle.html\" target=\"_blank\">IDLE</a>\n",
    "    * Installed with ArcGIS Desktop\n",
    "    * Can be used to run and edit scripts\n",
    "    * A little clunky for Python development...but is a standard software worth knowing\n",
    "\n",
    "\n",
    "* <a href=\"http://sourceforge.net/projects/pyscripter/files/\" target=\"_blank\">PyScripter</a>\n",
    "    * Good for Python 2 script development for ArcMap\n",
    "    * Can be used to run and edit scripts\n",
    "    * Download **v. 3.6.1 32-bit** version for ArcMap without 64-bit Background Geoprocessing\n",
    "    * Download **v. 3.6.1 64-bit** version for ArcMap with 64-bit Background Geoprocessing\n",
    "    * *NOTE: The zip files contain portable versions of PyScripter. No installation is needed. Just unzip the archive and start using PyScripter.*\n",
    "\n",
    "\n",
    "* <a href=\"https://www.spyder-ide.org/\" target=\"_blank\">Spyder</a>\n",
    "    * Better for scientific Python 3 and ArcGIS Pro development\n",
    "    * Requires special installaiton through ArcGIS Pro and/or Anaconda that may be tricky\n",
    "    * Easily run code in the application, but may require some setup\n",
    "\n",
    "\n",
    "* <a href=\"https://www.jetbrains.com/pycharm/\" target=\"_blank\">Pycharm</a>\n",
    "    * Good for all around Python 3 development\n",
    "    * Requires a normal installation from a free download\n",
    "    * Easily run code in the application, but may require some setup\n",
    "\n",
    "\n",
    "* There are many other script editors and IDEs! Always good to experiment with others\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download Exercise Data \n",
    "\n",
    "### From GitHub\n",
    "* Go to repo at **https://github.com/whitacrej/Python-for-ArcGIS-2021**\n",
    "* Click on the **Code** dropdown\n",
    "* Click **Download Zip**\n",
    "* **Extract** zip file to desktop or well-known folder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opening and Accessing Exercise Data and Scripts\n",
    "\n",
    "* All of the GIS data and ArcGIS Notebooks can be opened in ArcGIS Pro 2.5+\n",
    "* Python Scripts will need to be opened in a script editor or IDE\n",
    "\n",
    "### Note about ArcMap\n",
    "* ArcMap should be usable for all exercises, however it has not been tested\n",
    "* Jupyter Notebooks cannot be used with ArcMap; the ArcMap Python Window and script editors will need to be used to write and test code\n",
    "\n",
    "\n",
    "### ArcGIS vs. ArcMap vs. ArcGIS Pro\n",
    "\n",
    "* ArcGIS, ArcGIS Desktop, or Desktop = Both ArcMap AND ArcGIS Pro\n",
    "* ArcMap = ArcMap\n",
    "* ArcGIS Pro or Pro = ArcGIS Pro\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script Editor vs. Integrated Development Environment (IDE)\n",
    "\n",
    "### IDE\n",
    "* A software application that provides comprehensive facilities to computer programmers for software development (see https://en.wikipedia.org/wiki/Integrated_development_environment)\n",
    "* Allows for running and debugging code\n",
    "\n",
    "### Script Editor\n",
    "* Software that only allows textual code editing\n",
    "* Does not integrate running and debugging code on the base software; may be included as an extension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IDE: Jupyter Notebook\n",
    "\n",
    "\n",
    "### Jupyter\n",
    "\n",
    "- **Actually, it is [Project Jupyter](https://jupyter.org/)**\n",
    "\n",
    "<img alt=\"Jupyter Project logo\" style=\"height: 100px;\" src=\"https://jupyter.org/assets/homepage/main-logo.svg\">\n",
    "\n",
    "> Project Jupyter is a non-profit, open-source project, born out of the [IPython Project](https://ipython.org/) in 2014 as it evolved to support interactive data science and scientific computing across all programming languages. Jupyter will always be 100% open-source software, free for all to use and released under the liberal terms of the [modified BSD license](https://opensource.org/licenses/BSD-3-Clause).\n",
    "\n",
    "- **[IPython](https://ipython.org/) is...**\n",
    "\n",
    "![IPython Logo](https://ipython.org/_static/IPy_header.png)\n",
    "\n",
    "> IPython provides a rich architecture for interactive computing with:\n",
    ">\n",
    ">    - A powerful interactive shell.\n",
    ">    - A kernel for Jupyter.\n",
    ">    - Support for interactive data visualization and use of GUI toolkits.\n",
    ">    - Flexible, embeddable interpreters to load into your own projects.\n",
    ">    - Easy to use, high performance tools for parallel computing.\n",
    "\n",
    "- **So, it has it roots in Python**\n",
    "\n",
    "- **But can be used with other programming languages**\n",
    "\n",
    "\n",
    "### Jupyter Notebook\n",
    "\n",
    "<img atl=\"Jupyter Notebook Example\" style=\"width: 500px;\" src=\"https://jupyter.org/assets/homepage/jupyterpreview.webp\">\n",
    "\n",
    "- **Web-based application (i.e. browser-based) to help capture entire computational workflows and processes**\n",
    "\n",
    "    - Development\n",
    "    - Documentation\n",
    "    - Code execution\n",
    "    - Visualizing and communicationg results\n",
    "\n",
    "- **Main Features**\n",
    "\n",
    "    - Acts as an interactive IDE, including syntax highlighting, indentation, code completion\n",
    "    - Executes code directly in the browser environment and maintains results until cleared or when code is run again\n",
    "    - Utilizes Markdown markup language to provide additional code commentary or for presentations\n",
    "\n",
    "\n",
    "For further resources:\n",
    "\n",
    "Project Jupyter: https://jupyter.org/index.html\n",
    "\n",
    "Jupyter Notebook Documentation: https://jupyter-notebook.readthedocs.io/en/stable/index.html\n",
    "\n",
    "### Starting Jupyter Notebook\n",
    "\n",
    "* Go to **Start Menu > All Programs > ArcGIS > Jupyter Notebook**\n",
    "    * Wait for the Jupyter Notebook window to run and the dashboard to open in your default browser\n",
    "\n",
    "\n",
    "* Navigate to the folder where you extracted the **GitHub download**\n",
    "\n",
    "\n",
    "* Open the **Introduction to Python for ArcGIS.ipynb** Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Editor: Notepad++\n",
    "\n",
    "* Free (as in “free speech” and also as in “free beer”) source code editor and Notepad\n",
    "* Available for Windows\n",
    "* Comes with built-in support for JavaScript, TypeScript and Node.js\n",
    "* Rich ecosystem of extensions for other languages (such as C++, C#, Java, **Python**, PHP, Go) and runtimes (such as .NET and Unity).\n",
    "\n",
    "<img atl=\"Notepad++ Screenshot\" src=\"https://notepad-plus-plus.org/assets/images/notepad4ever.gif\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Editor: Visual Studio Code (or VS Code for short)\n",
    "\n",
    "* Lightweight but powerful desktop source code editor\n",
    "* Available for Windows, macOS and Linux\n",
    "* Comes with built-in support for JavaScript, TypeScript and Node.js\n",
    "* Rich ecosystem of extensions for other languages (such as C++, C#, Java, **Python**, PHP, Go) and runtimes (such as .NET and Unity).\n",
    "\n",
    "<img atl=\"Visual Studio Code Screenshot\" src=\"https://code.visualstudio.com/assets/home/home-screenshot-win-lg.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IDE: IDLE\n",
    "\n",
    "* Already installed as a part of ArcGIS Destkop Install...the fall back!\n",
    "\n",
    "* Let's take a quick tour!\n",
    "    * Two windows:\n",
    "        * Python shell window (interactive interpreter)\n",
    "        * Text Editor window (for scripts)\n",
    "\n",
    "<img atl=\"IDLE Screenshot\" src=\"https://bn1303files.storage.live.com/y4mE6K-TMvYDvLhdYNuf385Xw8a8HClFaFg66OmIBBZK8HkrjhHuSqa4kJZ1QKp66Ymou_n27Kxde12zRQj9TCjR6zOUccxOC31nnuQ-mo_dU2lQ0Td322Z4XYHXGxLtvYBNMAxlbY-aGBJeJ0h8AZtHs20zqUmeK_SLpd1DQQNFlB0oj-6JPW-VBYE7jpW_F97?width=847&height=433&cropmode=none\">\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type the code above into your IDE and run it....\n",
    "\n",
    "* I will give an explanation of concepts, then have code examples that can be run in the IDE in the grey boxes.\n",
    "\n",
    "* Please ***TYPE*** the code as we go and try to ***avoid copy and pasting*** unless instructed otherwise. Typing the code will help you learn it better!\n",
    "\n",
    "* When typing in the IDE, you will likely notice the auto complete functionality. Mastering this will help type code faster and with less mistakes. I will point out tips as we go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***Congratulations***, this is your first code!!!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# II. What is Python?\n",
    "\n",
    "* Python is an interpreted, object-oriented, high-level programming language with dynamic semantics\n",
    "* Good for scripting and for application development\n",
    "* Simple, easy to learn syntax emphasizing readability (**Great for beginners!!!**)\n",
    "* Has high-level built in data structures\n",
    "* Supports modules and packages, which encourages program modularity and code reuse\n",
    "* Increases productivity due to no compilation step\n",
    "* Debugging Python programs is easy; often the quickest way to debug a program is to add a few print statements to the code\n",
    "* Open-source and freely distributed\n",
    "\n",
    "*See <a href=\"https://www.python.org/doc/essays/blurb/\" target=\"_blank\">Python Software Foundation: What is Python Executive Summary</a> for more information*\n",
    "\n",
    "\n",
    "## ArcGIS Pro Python and ArcPy Documentation\n",
    "\n",
    "* Python in ArcGIS Pro: https://pro.arcgis.com/en/pro-app/arcpy/get-started/installing-python-for-arcgis-pro.htm*\n",
    "* Learning and understanding the ARcGIS Documentation on Python is very important!!!\n",
    "\n",
    "\n",
    "## Some General Notes\n",
    "\n",
    "* Learning a programming language is like like learning a new foreign language\n",
    "    * There is grammar, or syntax\n",
    "    * There is vocabulary, or tools, functions, methods, and modules\n",
    "    * It's a new way of thinking\n",
    "* People will refer to good code as being *'Pythonic'*\n",
    "* You may feel lost at first...practice and perseverence will help (I will try to go slow!)\n",
    "* Just like in ArcGIS, there is more than one way to do many things!\n",
    "\n",
    "**Disclaimer: The way I teach Python is specific to ArcGIS and covers the most important elements I have found to be helpful for beginners. Other Python instructors might emphasize other aspects more than I may.**\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III. Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print Statement\n",
    "\n",
    "* What is print statement?\n",
    "    * A way to make your script talk back to you\n",
    "    * A way to see what a variable is\n",
    "\n",
    "\n",
    "* How to use the print statement\n",
    "    * Type `print()`*\n",
    "    * Add the variable or string within the parentheses `()`\n",
    "\n",
    "*# Note: print() will work in both Python 2.x and Python 3.x, but using just `print ` without `()` is acceptable syntax in Python 2.x therefore the syntax above is preferred so that it is acceptable in both Python versions. We will use `print()` throughout this workshop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# This WILL work in Python 2.x and Python 3.x!!!\n",
    "print('Python is so cool!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# This WON'T work in Python 3.x (i.e. ArcGIS Pro)\n",
    "print 'Python is so cool!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "* What is a variable?\n",
    "    * Reserved memory locations to store values for repeated use in the code\n",
    "    * When you create a variable you reserve space in memory for the value\n",
    "    * Stored as a specific data type (e.g. string, integer, floating point, list, dictionary, etc.)\n",
    "    * Value and data type can be changed, or reassigned, very simply\n",
    "\n",
    "* How to set, or declare, a variable\n",
    "    * No explicit declaration needed\n",
    "    * Type a descriptive word that represent what you want to store for use later\n",
    "    * Type the equals sign: `=`\n",
    "    * Type what the variable equals\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "food = 'cheese'\n",
    "\n",
    "food_count = 6\n",
    "\n",
    "print(food)\n",
    "print(food_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cool tips...\n",
    "\n",
    "food, food_count = 'bread', 100\n",
    "\n",
    "print(food)\n",
    "print(food_count)\n",
    "\n",
    "food1 = food2 = food3 = 'banana'\n",
    "\n",
    "print(food1)\n",
    "print(food2)\n",
    "print(food3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Data Types\n",
    "\n",
    "| Data Type | Examples |\n",
    "|:--- |:---|\n",
    "| String | **`“cheese”`** or **`'Food Time'`** |\n",
    "| Integer Number | **`68`** or **`23456`** or **`0`** |\n",
    "| Float Number | **`345.67`** or **`28.1`** or **`98.0`** |\n",
    "| Boolean | **`True`** or **`False`** |\n",
    "| List | **`[“apple”, “orange”]`** |\n",
    "| Tuple | **`(“apple”, “orange”)`** |\n",
    "| Dictionary | **`{“lat”:39.799, “lon”:-89.64}`** |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Strings\n",
    "\n",
    "* What is a string?\n",
    "    * Contiguous set of characters represented in quotation marks\n",
    "    * Simply put, it is text values\n",
    "    * Number characters are not treated like numbers (i.e. `1 != '1'`)\n",
    "\n",
    "\n",
    "* What can you do with a string?\n",
    "    * Concatenation\t(ex: `'cheese ' + 'whiz'` will equal `'cheese whiz'` *Note the space!!*)\n",
    "        * Plus (+) sign is the string concatenation operator (can only operate on all string values: `'cheese' + 1` is an error)\n",
    "        * Asterisk (*) is the repetition operator: `'cheese' ** 3` is `'cheesecheesecheese'`\n",
    "\n",
    "    * Slicing (e.g.:  `'cheese'[1:4]` will equal `'hee'` as the index starts a 0)\n",
    "\n",
    "\n",
    "<img atl=\"Python slicing\" src=\"https://bn1305files.storage.live.com/y4mYwVnBBth9UvYWZnRvKHmHu21-nKSqVBZrd7_NKJWRpnzr0oaLIybzYJOzrnF5VwziPTw3srdGc4Drq-mTwLG6ZpII8fJoUYDuG0UCSQ-gHflDbQrc4nC_jqi4rNEOjtoSwqsud1cy0gZx_ldIyh3oCOkf1pIsH6ocZ-ZDNpWVB-Fk6kdCTadgnN19nhcXsqk?width=575&height=216&cropmode=none\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('cheese ' + 'whiz') # Note the space...\n",
    "print('cheese' * 3) # Note no space...\n",
    "print('cheese'[1:4])\n",
    "print('cheese'[:2])\n",
    "print('cheese'[:-2])\n",
    "print('cheese'[2:])\n",
    "print('cheese'[-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Numbers\n",
    "\n",
    "* Number datatypes store numeric values that act like numbers (e.g. for math operations)\n",
    "\n",
    "\n",
    "* **Integer**: Number **without** decimal\n",
    "\n",
    "\n",
    "* **Float**: Number **with** decimal\n",
    "\n",
    "\n",
    "* What can you do with numbers?\n",
    "    * Simple math - e.g: \n",
    "        \n",
    "```python\n",
    "    5 + 7 – 3\n",
    "```        \n",
    "        \n",
    "    * Math with variables - e.g.:\n",
    "        \n",
    "```python\n",
    "    three = 3\n",
    "    5 + 7 – three\n",
    "```\n",
    "\n",
    "\n",
    "*In ArcGIS, feature class attribute tables will have long and short integers and float and double precision numbers. In Python, integers are treated like long and float is treated like double precsision.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 + 7 - 3)\n",
    "\n",
    "three = 3.3\n",
    "\n",
    "print(type(three))\n",
    "\n",
    "print(5 + 7 - three)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Booleans\n",
    "\n",
    "* Boolean values are `True` or `False`\n",
    "* Used for evaluating whether something is `True` or `False`\n",
    "* The following will be evaluated as `False`:\n",
    "    * `None`\n",
    "    * `False`\n",
    "    * Zero of any numeric type (i.e. `0`)\n",
    "    * Any empty sequence (e.g. `''`,`()`,`[]`)\n",
    "    * Any empty dictionary (e.g. `{}`)\n",
    "* Use the `bool()` function to evaluate a variable's boolean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What boolean value will each variable evalute to? \n",
    "\n",
    "a = True\n",
    "b = 'False'\n",
    "c = ''\n",
    "d = 0\n",
    "e = 1 # Try negative 1!\n",
    "f = [1]\n",
    "g = []\n",
    "\n",
    "print(bool(a))\n",
    "print(bool(b))\n",
    "print(bool(c))\n",
    "print(bool(d))\n",
    "print(bool(e))\n",
    "print(bool(f))\n",
    "print(bool(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "* What is a list?\n",
    "    * Series of ordered items or objects\n",
    "    * Compund data type\n",
    "    * Enclosed by square brackets `[]` and items separated with commas `,`\n",
    "    * Lists are mutable, (i.e. items and number of items can be changed, replaced, added, or deleted)\n",
    "\n",
    "\n",
    "* How are lists used?\n",
    "    * Find one or a range of items\n",
    "```python\n",
    "        fruitlist = ['apples', 'oranges', 'bananas']\n",
    "        fruitlist[1] # returns oranges\n",
    "        fruitlist[1:3] # returns ['oranges', 'bananas']\n",
    "```\n",
    "\n",
    "    * Iterate through it (use a loop)\n",
    "```python\n",
    "        fruitlist = ['apples', 'oranges', 'bananas']\n",
    "        \n",
    "        for fruit in fruitlist:\n",
    "        # Do somthing...\n",
    "            print(fruit)\n",
    "```\n",
    "    * Change list values\n",
    "```python\n",
    "        fruitlist[1] = 'peaches'\n",
    "        fruitlist.append('cherries')\n",
    "        fruitlist.remove('apples')\n",
    "        \n",
    "        print(fruitlist) # returns ['peaches', 'bananas', 'cherries']\n",
    "```\n",
    "\n",
    "See https://www.tutorialspoint.com/python/python_lists.htm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruitlist = ['apples', 'oranges', 'bananas']\n",
    "\n",
    "print(fruitlist)\n",
    "\n",
    "print(fruitlist[1])\n",
    "\n",
    "print(fruitlist[1:3])\n",
    "\n",
    "print(len(fruitlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterate over the list...more on this later        \n",
    "for fruit in fruitlist:\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change the list...\n",
    "fruitlist = ['apples', 'oranges', 'bananas']\n",
    "\n",
    "fruitlist[1] = 'peaches'\n",
    "fruitlist.append('cherries')\n",
    "fruitlist.remove('apples')\n",
    "del fruitlist[1]\n",
    "        \n",
    "print(fruitlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "* What is a tuple?\n",
    "    * Similar to a list, but enclosed by parentheses `()`\n",
    "    * Immutable (i.e. not changeable; read-only)\n",
    "\n",
    "\n",
    "* How are tuples used?\n",
    "    * Find one or a range of items\n",
    "```python\n",
    "        fruittuple = ('apples', 'oranges', 'bananas')\n",
    "        fruittuple[1] # returns oranges\n",
    "        fruittuple[1:3] # returns (oranges, bananas)\n",
    "```\n",
    "    * Iterate through it (use a loop)\n",
    "```python\n",
    "        fruittuple = ('apples', 'oranges', 'bananas'])\n",
    "        \n",
    "        for fruit in fruittuple:\n",
    "        # Do somthing...\n",
    "            print(fruit)\n",
    "```\n",
    "\n",
    "**Tuples are important when you need to preserve data that you don't want to change. In ArcGIS, cursors always create tuples for this reason...more on that later.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruittuple = ('apples', 'oranges', 'bananas')\n",
    "\n",
    "print(fruittuple)\n",
    "print(fruittuple[1])\n",
    "print(fruittuple[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruittuple = ('apples', 'oranges', 'bananas')\n",
    "        \n",
    "for fruit in fruittuple:\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fruittuple[1] = 'peaches' # Invalid syntax with tuple, this will produce an error, but it will work for a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "* What is a dictionary?\n",
    "    * An *unordered* set of `key:value` pairs enclosed by curly brackets `{}`\n",
    "    * **Keys** must be unique values and are typically numbers or strings in quotes, but can be other Python data types\n",
    "    * **Values** can be any Python object\n",
    "\n",
    "\n",
    "* How are dictionaries used?\n",
    "    * Find the value that goes with a key\n",
    "```python\n",
    "        dicttest = {'key':'value', 'lat':39.98, 'long': -89.65}\n",
    "        dicttest['key'] # returns value\n",
    "        dicttest['lat'] # returns 39.98\n",
    "        dicttest['long'] # returns -89.65\n",
    "```\n",
    "    * Get a list of keys\n",
    "```python\n",
    "        dicttest.keys() # returns ['key', 'lat', 'long']\n",
    "```\n",
    "\n",
    "    * Get a list of values\n",
    "```python\n",
    "        dicttest.values() # returns ['value', 39.98, -89.65]\n",
    "```\n",
    "\n",
    "    \n",
    "**Note: Dictionaries are good to know about, but we will not work with them in much detail for this workshop.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dicttest = {'key':'value', 'lat':39.98, 'long': -89.65}\n",
    "\n",
    "print(dicttest['key'])\n",
    "print(dicttest['lat'])\n",
    "print(dicttest['long'])\n",
    "\n",
    "print(dicttest.keys())\n",
    "\n",
    "print(dicttest.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Data Type Conversion\n",
    "\n",
    "* Converting between data types is common\n",
    "* There are built-in functions to deal with this\n",
    "* Example: You want to concatenate a numerical value into a string\n",
    "* There are also functions to determine what the data type is of a variable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the following code...What happens?\n",
    "\n",
    "x = 99\n",
    "\n",
    "print(\"There are \" + x + \" files.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change x to be str(x)\n",
    "\n",
    "print(\"There are \" + str(x) + \" files.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 99\n",
    "s = \"99\"\n",
    "l = [s, x]\n",
    "t = (s, x)\n",
    "\n",
    "print(type(x))\n",
    "print(type(s))\n",
    "print(type(l))\n",
    "print(tuple(l))\n",
    "print(type(t))\n",
    "print(list(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Math with Python\n",
    "\n",
    "### Python Arithmetic Operators\n",
    "\n",
    "| Operator | Description | Example |\n",
    "|:--- |:---|:---:|\n",
    "| `+` Addition | Adds values on either side of the operator. | `a + b = 30` |\n",
    "| `-` Subtraction | Subtracts right hand operand from left hand operand. | `a – b = -10` |\n",
    "| `*` Multiplication | Multiplies values on either side of the operator | `a * b = 200` |\n",
    "| `/` Division | Divides left hand operand by right hand operand | `b / a = 2` |\n",
    "| `%` Modulus | Divides left hand operand by right hand operand and returns remainder | `b % a = 0` |\n",
    "| `**` Exponent | Performs exponential (power) calculation on operators | `a**b =10 to the power 20` |\n",
    "| `//` Floor Division | The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity): | `9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0` |\n",
    "\n",
    "\n",
    "### More Examples\n",
    "\n",
    "|Operator | Explanation | Example | Result |\n",
    "|:---:|:--- |:---:|:---:|\n",
    "| `x + y` | x plus y | `1.5 + 2.5` | `4.0` |\n",
    "| `x - y` | x minus y | `3.3 - 2.2` | `1.1` |\n",
    "| `x * y` | x times y | `2.0 * 2.2` |  `4.4` |\n",
    "| `x / y` | x divided by y | `4.0 / 1.25` | `3.2` |\n",
    "| `x // y` | x divided by y (floor division) | `4.0 // 1.25`| `3.0` |\n",
    "| `x % y` | x modulo y | `8 % 3` | `2` |\n",
    "| `-x` | negative expression of x | `x = 5; -x` | `-5` |\n",
    "| `+x` | x is unchanged | `x = 5; +x` | `5` |\n",
    "| `x ** y` | x raised to the power of y | `2 ** 3` | `8` | \n",
    "\n",
    "\n",
    "*Source: http://desktop.arcgis.com/en/arcmap/latest/tools/data-management-toolbox/calculate-field-examples.htm*\n",
    "\n",
    "\n",
    "**When performing field calculations with a Python expression, Python math rules are in effect. For example, dividing two integer values will always produce an integer output (3 / 2 = 1). To get decimal output:**\n",
    "\n",
    "* One of the numbers in the operation must be a decimal value: `3.0/2 = 1.5`\n",
    "\n",
    "\n",
    "* Use the float function to explicitly convert the value to a float:\n",
    "\n",
    "\n",
    "```python\n",
    "    float(3)/2 = 1.5\n",
    "    \n",
    "    # or\n",
    "    \n",
    "    3/float(2) = 1.5\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(1.5 + 2.5)\n",
    "\n",
    "print(3.3 - 2.2)\n",
    "\n",
    "print(2.0 * 2.2)\n",
    "\n",
    "print(4.0 / 1.25)\n",
    "\n",
    "print(4.0 // 1.2)\n",
    "\n",
    "print(8 % 3)\n",
    "\n",
    "x = 5 \n",
    "print(-x)\n",
    "print(+x)\n",
    "\n",
    "print(2 ** 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Basic Syntax\n",
    "\n",
    "* Variables cannot start with a number or have a space in it\n",
    "```python\n",
    "    1line = 5 # This will not work...\n",
    "\n",
    "    a line = 5 # Neither will this...\n",
    "```\n",
    "\n",
    "* Here is a list of common ***reserved words***; do **NOT** use these as variable names:\n",
    "```python\n",
    "    and, del, from, not, while, as, elif, global, or, with, assert, else, if, pass, yield, break, except, import, \n",
    "    print, class, exec, in, raise, continue, finally, is, return, def, for, lambda, try\n",
    "```\n",
    "    * Basically, if it turns a color when you are done typing it, don’t use it as your variable’s name!\n",
    "    * There are likely many more reserved words!\n",
    "\n",
    "\n",
    "* Variable name capitalization matters!!\n",
    "```python\n",
    "    Cat != cat\n",
    "```\n",
    "\n",
    "* Colons matter!! AND...\n",
    "    * Indentation matters!!\n",
    "```python\n",
    "    if x\n",
    "    print(x)\n",
    "\n",
    "    # Will not work, but this will:\n",
    "    if x:\n",
    "    ....print(x)\n",
    "```\n",
    "    * Typically 2 or 4 spaces (represented by '.')\n",
    "    * 4 spaces are prefered (using Tab in the IDE should do this automatically)\n",
    "\n",
    "\n",
    "* Quotations are a bit tricky, but very cool\n",
    "    * Single (`'`), double (`\"`) and triple-single and triple-double (`'''` or `\"\"\"`) quotes can be used to denote strings\n",
    "    * Make sure to end the string denotation with the same type of quote structure\n",
    "    * Single quotes (`'`) are the easiest to type (no Shift!!), so I default to them usually\n",
    "\n",
    "```python\n",
    "    # Examples\n",
    "    \n",
    "    word1 = 'Dog'\n",
    "    word2 = \"'Dog'\"\n",
    "    word3 = '\"Dog\"'\n",
    "    print(word1, word2, word3)\n",
    "    # The three words above will print: Dog, 'Dog', and \"Dog\"\n",
    "    \n",
    "    words1 = 'That's the dog's toy' # Is a syntax error\n",
    "    words2 = \"That's the dog's toy\" # Prints: That's the dog's toy\n",
    "    \n",
    "    more_words = \"\"\"She said, \"Good dog!\" And the dog's tail wagged.\"\"\"\n",
    "    # Prints: She said, \"Good dog!\" And the dog's tail wagged.\n",
    "```\n",
    "\n",
    "* Backslashes can be confusing...\n",
    "```python\n",
    "    # These are all the same thing...\n",
    "    'C:\\\\data\\\\things' # I prefer this one when working in ArcGIS Pro...I will tell you why later\n",
    "    'C:/data/things'\n",
    "    r'C:\\data\\things' # I prefer this one when working in ArcMap...I will tell you why later\n",
    "```\n",
    "\n",
    "* Commenting is great!!\n",
    "    * Use it to help document and explain your code...we will do this throughout the exercises!\n",
    "    * Comments are not run in code; they are ignored\n",
    "    * Blank lines are also ignored\n",
    "```python\n",
    "    # This is a block comment\n",
    "    ## So is this\n",
    "    ### The blank line below this one will be ignored\n",
    "    \n",
    "    \"\"\" This is good for multi-line block comments\n",
    "    Notice that this line is still a comment\n",
    "    Use block commnets as mush as you need, but not too much\n",
    "    Don't forget to close the multi-line comment\"\"\"\n",
    "    \n",
    "    s = 'something' # This is an in-line comment...use these sparingly in your code\n",
    "```\n",
    "\n",
    "### See the <a href=\"https://www.python.org/dev/peps/pep-0008/\" target=\"_blank\">PEP 8 -- Style Guide for Python Code</a> for more information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements and Decision Making\n",
    "\n",
    "\n",
    "* Many times, we need code to make decisions\n",
    "* Some decisions are easy, while others are complex\n",
    "* Decision are made by evaluating whether something is `True` or `False`\n",
    "\n",
    "<img atl=\"Decision making statements in Python\" src=\"https://www.tutorialspoint.com/python/images/decision_making.jpg\">\n",
    "\n",
    "\n",
    "*Source: https://www.tutorialspoint.com/python/python_decision_making.htm*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if` Statements\n",
    "\n",
    "* `if` statement - one decision/option\n",
    "```python\n",
    "    # If 'x' is True\n",
    "    if x == 100: # Note the colon (:) and the double equals sign (==)\n",
    "        \n",
    "        # Do something or many things\n",
    "        x = x + 1 # Note the indentation\n",
    "        print(x)\n",
    "```\n",
    "\n",
    "* `if`...`else` statement - two decisions/options\n",
    "```python\n",
    "    # If 'x' is True\n",
    "    if x == 100:\n",
    "        # Do something or many things\n",
    "        x = x + 1\n",
    "        print(x)\n",
    "\n",
    "    # If 'x' is NOT True\n",
    "    else:\n",
    "        # Do something else\n",
    "        x = x - 1\n",
    "        print(x)\n",
    "```\n",
    "\n",
    "* `if`...`elif`...`else` statement - many decisions/options\n",
    "```python\n",
    "    if x == 100:\n",
    "        x = x + 1\n",
    "        print(x)\n",
    "\n",
    "    # If 'x' is NOT True, try 'y'\n",
    "    elif y == 100:\n",
    "        y = x + y\n",
    "        print(y)\n",
    "\n",
    "    # If 'y' is NOT True, try 'z'\n",
    "    elif z == 100:\n",
    "        z = x ** y\n",
    "        print(z)\n",
    "\n",
    "    # If everything is NOT True\n",
    "    else:\n",
    "        w = y % z\n",
    "        print(w)\n",
    "```\n",
    "\n",
    "* `if` statements can be nested\n",
    "```python\n",
    "\n",
    "    if x == 100:\n",
    "        x = x + 1\n",
    "        print(x)\n",
    "\n",
    "        # If 'x' is True, AND 'y' is True\n",
    "        if y == 100: # ****Notice the second indent!!****\n",
    "            y = x + y\n",
    "            print(y)\n",
    "\n",
    "        # If 'x' is True, but 'y' is NOT True\n",
    "        else:\n",
    "            z = x ** y\n",
    "            print(z)\n",
    "\n",
    "    # If 'x' is NOT True\n",
    "    else:\n",
    "        w = y % z\n",
    "        print(w)\n",
    "```\n",
    "\n",
    "*Note: No `end if` is required like many other coding languages! Just unindent to show the end of the section.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators\n",
    "\n",
    "| Operator | Description | Example |\n",
    "| :---: | :--- | :---: |\n",
    "| == | If the values of two operands are equal, then the condition becomes true. | (1 == 2) is NOT true |\n",
    "| != | If values of two operands are not equal, then condition becomes true. | (1 != 2) is true |\n",
    "| <> | If values of two operands are not equal, then condition becomes true. *This is the same as != operator, but is deprecated and not valid in Python 3.* | (1 <> 2) is true |\n",
    "| > | If the value of left operand is greater than the value of right operand, then condition becomes true. | (1 > 2) is not true. |\n",
    "| < | If the value of left operand is less than the value of right operand, then condition becomes true. | (1 < 2) is true. |\n",
    "| >= | If the value of left operand is greater than or equal to the value of right operand, then condition becomes true. | (1 >= 2) is not true.|\n",
    "| <= | If the value of left operand is less than or equal to the value of right operand, then condition becomes true. | (1 <= 2) is true. |\n",
    "| and | Called Logical AND operator. If both the operands are true then then condition becomes true. | (a and b) is true |\n",
    "|or | Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. | (a or b) is true |\n",
    "| not | Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | not(a && b) is false |\n",
    "| in | Evaluates to true if it finds a variable in the specified sequence and false otherwise. | x in y, here in results in a 1 if x is a member of sequence y |\n",
    "| not in | Evaluates to true if it does not find a variable in the specified sequence and false otherwise. | x not in y, here not in results in a 1 if x is not a member of sequence y |\n",
    "\n",
    "*Adapted from: https://www.tutorialspoint.com/python/python_basic_operators.htm*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 21\n",
    "b = 10\n",
    "c = 0\n",
    "\n",
    "if a == b:\n",
    "    print(\"Line 1 - a is equal to b\")\n",
    "else:\n",
    "    print(\"Line 1 - a is not equal to b\")\n",
    "\n",
    "if a != b:\n",
    "    print(\"Line 2 - a is not equal to b\")\n",
    "else:\n",
    "    print(\"Line 2 - a is equal to b\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is novalid in Python 3:\n",
    "if a <> b: \n",
    "   print(\"Line 3 - a is not equal to b\")\n",
    "else:\n",
    "   print(\"Line 3 - a is equal to b\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a < b:\n",
    "    print(\"Line 4 - a is less than b\")\n",
    "else:\n",
    "    print(\"Line 4 - a is not less than b\")\n",
    "\n",
    "if a > b:\n",
    "    print(\"Line 5 - a is greater than b\")\n",
    "else:\n",
    "    print(\"Line 5 - a is not greater than b\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5;\n",
    "b = 20;\n",
    "\n",
    "if a <= b:\n",
    "    print(\"Line 6 - a is either less than or equal to  b\")\n",
    "else:\n",
    "    print(\"Line 6 - a is neither less than nor equal to  b\")\n",
    "\n",
    "if b >= a:\n",
    "    print(\"Line 7 - b is either greater than  or equal to b\")\n",
    "else:\n",
    "    print(\"Line 7 - b is neither greater than  nor equal to b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "\n",
    "* Block of organized, reusable code\n",
    "* Performs a single, related action\n",
    "* Good when a funcion needs to be reused a lot\n",
    "* Many built-in functions (e.g. `print()` and `str()`)\n",
    "* Users can create their own function, commonly referred to as *user-defined* functions\n",
    "\n",
    "### Defnining Funcitons\n",
    "\n",
    "* Function blocks begin with the keyword def followed by the function name and parentheses `()`.\n",
    "\n",
    "\n",
    "* Any input parameters or arguments should be placed within these parentheses. You can also define parameters inside these parentheses.\n",
    "\n",
    "\n",
    "* The first statement of a function can be an optional statement - the documentation string of the function or docstring.\n",
    "\n",
    "\n",
    "* The code block within every function starts with a colon (:) and is indented.\n",
    "\n",
    "\n",
    "* The statement return [expression] exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.\n",
    "\n",
    "```python\n",
    "    # Basic Funtion syntax\n",
    "\n",
    "    def functionname( parameters ):\n",
    "        \"\"\"function_docstring\"\"\" # This is optional, note triple-quotes\n",
    "        # Function code\n",
    "        return #expression\n",
    "```\n",
    "\n",
    "\n",
    "*Source: https://www.tutorialspoint.com/python/python_functions.htm*\n",
    "\n",
    "*Script Source: https://www.codecademy.com/learn/python*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tax(bill):\n",
    "    \"\"\"Calculates 8% tax of restaurant bill.\"\"\"\n",
    "    tax = bill * 0.08\n",
    "    print('Tax: ${:0.2f}'.format(tax))\n",
    "    return tax\n",
    "\n",
    "def tip(bill):\n",
    "    \"\"\"Calculates 15% tip of restaurant bill.\"\"\"\n",
    "    tip = bill * 0.15\n",
    "    print('Tip: ${:0.2f}'.format(tip))\n",
    "    return tip\n",
    "\n",
    "def totalbill(bill, tax, tip):\n",
    "    \"\"\"Calculates the total restaurant bill.\"\"\"\n",
    "    total = bill + tax + tip\n",
    "    print('Total: ${:0.2f}'.format(total))\n",
    "    return total\n",
    "\n",
    "# Change the meal_cost value a few times to see how the results change\n",
    "meal_cost = 100\n",
    "print('Bill: ${:0.2f}'.format(meal_cost))\n",
    "\n",
    "meal_tax = tax(meal_cost)\n",
    "meal_tip = tip(meal_cost)\n",
    "meal_total = totalbill(meal_cost, meal_tax, meal_tip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "* Code is generally executed consecutively\n",
    "* Loops allow for a block of code to be executed several times\n",
    "* Two basic types: `for` and `while` loops\n",
    "\n",
    "<img atl=\"Loop Architecture\" src=\"https://www.tutorialspoint.com/python/images/loop_architecture.jpg\">\n",
    "\n",
    "See https://www.tutorialspoint.com/python/python_loops.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` Loops\n",
    "\n",
    "* Work on ordered lists and other sequences\n",
    "* Repeats a block of code for each element of the list\n",
    "* When the end of the list is reached, the loop ends\n",
    "\n",
    "```python\n",
    "    for item in list_of_items:\n",
    "        # Do some code...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = ['a', 'b', 'c', 'd']\n",
    "\n",
    "for item in a_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` Loops\n",
    "\n",
    "* Executes the code block while a gived condition is true\n",
    "* Requires an exit condition, otherwise it could be an infinite loop (this is bad!!)\n",
    "\n",
    "```python\n",
    "    i = 0 # This is called a sentry variable\n",
    "    while i <= 10:\n",
    "        print(i)\n",
    "        i += 1 # Increment the sentry variable to ensure the exit condition\n",
    "```\n",
    "\n",
    "\n",
    "`i =+ 1` *is another way to increment a numeric value by a constance value (in this case `1`).*\n",
    "\n",
    "*See https://www.tutorialspoint.com/python/assignment_operators_example.htm for other similar operations. Python is full of these types of tricks!*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "\n",
    "while i <= 10:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Yay for Python!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***Congratulations***, you're on your way to using Python!!!\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "ArcGISPro",
   "language": "Python",
   "name": "python3"
  },
  "language_info": {
   "file_extension": ".py",
   "name": "python",
   "version": "3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}