U_CSCI2011_L01_Welcome_to_Fundamentals_I_SG_V3.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><center>UNCLASSIFIED</center></b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<img src=\"./GRAPHICS/Banner.png\" width=\"100%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 1: Welcome to Fundamentals I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "1.1. [Objectives](#Objectives)<br>\n",
    "1.2. [Overview](#Overview)<br>\n",
    "1.3. [Course Overview](#CourseOverview)<br>\n",
    "1.4. [Additional Assistance](#Additional)<br>\n",
    "1.5. [Jupyter Notebook Basics](#Jupyter)<br>\n",
    "1.6. [Python](#Python)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.1. [Python 3](#Python3)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.2. [Some Vocabulary for Python](#Vocabulary)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.3. [Guided Exercise: Finding the Square Root](#Square)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.4. [Python Resources](#Resources)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.5. [Reserved Keywords and Built-In Functions](#Keywords)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.6.6. [Python's `help()` Function](#Help)<br>\n",
    "1.7. [Jupyter Notebook Tips and Tricks](#AdvJupyter)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.7.1. [Keyboard Shortcuts](#Notebooks)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.7.2. [The Kernel Menu](#Kernel)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.7.3. [Output vs. `print()`](#output)<br>\n",
    "1.8. [Computational Thinking](#ComputationalThinking)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.8.1. [Guided Exercise: Apply Computational Thinking](#compt_ge)<br>\n",
    "1.9. [Practice Python](#PracticePython)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.9.1. [Hard-Coding vs. Programmatic Coding](#PracticePython)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;1.9.2. [Storing Values in Variables](#variables)<br>\n",
    "1.10. [Appendix](#appendix)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <a id='Objectives'></a>\n",
    "\n",
    "## 1.1. Objectives\n",
    "\n",
    "* Examine the implications of using computation to solve a problem\n",
    "    * Discuss best practices for using computation to solve a problem\n",
    "    * Suggest types of problems that can be solved through computation\n",
    "    * Show how computation can solve a problem\n",
    "<br><br>    \n",
    "* Recognize key computer science concepts\n",
    "    * Identify data types used in Python scripting\n",
    "    * Identify data structures used in Python scripting\n",
    "    * Define variables and strings\n",
    "    * Recognize how queries operate\n",
    "<br><br>    \n",
    "* Demonstrate the ability to build basic scripts using Python scripting language\n",
    "    * Use various data types and structures in Python scripting\n",
    "    * Collect data using Python scripting\n",
    "    * Extract data using Python scripting\n",
    "    * Develop advanced data structures using Python scripting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Overview'></a>\n",
    "\n",
    "## 1.2. Overview\n",
    "\n",
    "The following lesson is broken up into the following parts:\n",
    "* Course Overview\n",
    "* Additional Assistance\n",
    "* Computational Thinking\n",
    "* Python\n",
    "* Using Jupyter Notebook\n",
    "* Practice Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='CourseOverview'></a>\n",
    "\n",
    "## 1.3. Course Overview\n",
    "\n",
    "This is an instructor-led course designed to help shift how you think about solving problems. Its intent is to show you the potential application of coding as a tool to solve problems. This course will not turn you into a computer scientist, data scientist, or Silicon Valley CEO in 40 hours of classroom time. The emphasis is data-related learning objectives that can help you meet the mission with greater speed and precision."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"Additional\"></a>\n",
    "\n",
    "## 1.4. Additional Assistance\n",
    "\n",
    "| Type | When |\n",
    "|---|---|\n",
    "| **Open Lab with Instructors** | Monday - Thursday, 1500-1600 |\n",
    "| **Community of Practice (CoP)** | Anytime, anywhere |\n",
    "\n",
    "\n",
    "There are multiple services and groups available upstairs that can help you with your coding development by providing additional resources, skills, and even desk-side assistance. <br>\n",
    "\n",
    "| Title | Service | Contact |\n",
    "|:------|:------|:------|\n",
    "| **SBU** | Access to Google, StackExchange, etc. | NA |\n",
    "| **Python Party** | Community of coders who share their coding success stories and answer<br>questions from the coding community.| https://rspace.dodiis.ic.gov/rspace/groups/python-party |\n",
    "| **OHI** | Desk-side assistance with coding and assistance with JupyterHub. | https://intellipedia.intelink.ic.gov/wiki/NGA%27s_Office_Hours_Initiative |\n",
    "| **ADV** | Developer tools (including Python documentation), stack exchange mirror,<br>and a highside PyPI repository, among other resources. | TBA |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"Jupyter\"></a>\n",
    "\n",
    "## 1.5. Jupyter Notebook Basics\n",
    "\n",
    "As shown below, Jupyter Notebooks consist of a number of code or Markdown cells. Set the type of any cell with the drop-down on the right end of the toolbar. Markdown allows you to write notes and text in various forms such as lists or tables. The Jupyter Notebook User's Manual is a great resource to learning more details about Markdown formatting.\n",
    "\n",
    "![](./GRAPHICS/Jupyter_Toolbar.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Use the \"Run Cell\" button to run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1111 * 1111"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add a cell below this one using the \"Add Cell\" button."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Copy the cell you just added and paste it below this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise: What is the type of this cell?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: What is the type of this cell?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Python'></a>\n",
    "\n",
    "## 1.6. Python\n",
    "\n",
    "#### References:\n",
    "* [Wikipedia: Python (programming language)](https://en.wikipedia.org/wiki/Python_%28programming_language%29)\n",
    "\n",
    "Python is a widely used programming language for general-purpose programming. Python was created by Guido van Rossum and first released in 1991. Python has a design philosophy that emphasizes code readability (notably using whitespace indentation to delimit code blocks rather than curly brackets or keywords), and a syntax that allows programmers to express concepts in fewer lines of code than might be used in languages such as C++ or Java. Van Rossum is Python's principal author, and his role in deciding the direction of Python is reflected in the title given to him by the Python community: Benevolent Dictator For Life (BDFL).\n",
    "\n",
    "Python is named after [Monty Python's Flying Circus](https://en.wikipedia.org/wiki/Monty_Python%27s_Flying_Circus). The core philosophy of the language is summarized by the document [The Zen of Python](https://en.wikipedia.org/wiki/Zen_of_Python), which includes aphorisms such as:\n",
    "\n",
    "* Beautiful is better than ugly\n",
    "* Explicit is better than implicit\n",
    "* Simple is better than complex\n",
    "* Complex is better than complicated\n",
    "* Readability counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [PEP8 Style Guide for Python](https://www.python.org/dev/peps/pep-0008/) is a fairly short web document.  Although your Python code is not being graded for style in this course, it is a good practice to adhere to the Python Style Guide if only to increase the readability of your code by others, especially if you are seeking their help to solve a problem.\n",
    "\n",
    "Some Python style highlights:\n",
    "\n",
    "* **Indentation** - Use four spaces per indentation level (Tabs are set to four spaces in Jupyter Notebooks)\n",
    "* **Naming Variables** - lower_case_with_underscores\n",
    "    * *Function and Variable Names* - Names should be lowercase, with words separated by underscores as necessary to improve readability.\n",
    "    * *Constants* - Constants are usually defined on a module level and written in all capital letters with underscores separating words. Examples include PLANCKS_CONSTANT and PI.\n",
    "\n",
    "Regardless of whether you adhere to a style guide or not, try to be consistent in your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Python3'></a>\n",
    "\n",
    "### 1.6.1. Python 3\n",
    "\n",
    "In the classroom, we will be using Python 3. Some of you who've used Python before might have used older versions.  There are slight differences between versions, but we will stay consistent throughout the course with version 3, and point out some major differences between Python 2 and Python 3 along the way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Vocabulary'></a>\n",
    "\n",
    "### 1.6.2. Some Vocabulary for Python \n",
    "\n",
    "Here is list of some common terms and concepts that you will hear in this course.\n",
    "\n",
    "* **Syntax** - Syntax refers to how you write code, such as spacing, punctuation, and indentation.  Python depends on correct syntax to properly read and execute the code you write.  A single mistake in syntax will cause Python to execute the code differently than you intended or to throw an error, meaning Python will stop running your code and then give you an error message describing what went wrong.\n",
    "\n",
    ">REMEMBER: Computers are not smart; they are just really fast. Python syntax is designed to ensure there is no ambiguity in your instructions to the computer.\n",
    "\n",
    "* **Variable** - A variable name is a stand-in for some data value.  Think back to when you learned to use \"x\" as a stand-in for numbers in math class.  Variables in code work just like this, but are more powerful.  A variable name in Python can be any letter, word, or series of words linked by underscores (`_`). Although you can use almost any word for variable names, the best practice is to be _descriptive_. Variables stand in not just for numbers, but also for text, Boolean values, lists of things, or any other type of data. To assign a data value to a variable in Python, we use a single equals sign, like `x = 4` or `some_text = 'Hello world!'`.\n",
    "\n",
    "\n",
    "\n",
    "* **Comment** - A comment is text that is ignored by the computer. It is a description that provides more information about the thought process or logic that the code is representing. Any text that follows a pound sign (`#`) in a line of code will be considered a comment, and will not be evaluated by the computer. This allows us to leave notes for ourselves and other developers to reference."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** In the code cell below, the variable `y` is assigned to the integer `4`. Create a new variable `z` and assign it the integer `3`. Then, add `y + z` and run the code you have written."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Function** or **Method** - Think of functions and methods as little programs or apps.  They are bodies of code that take specified input(s), do some actions (even running other functions), and then usually provide some output.  You can think of every computer program you use (i.e., Microsoft Word, Internet Explorer, Super Mario, etc.) as a group of functions that work together to carry out all of the things the program does.  You will be writing some simple functions in this course before too long.\n",
    "\n",
    "> NOTE: The name of a Python function is always followed by parentheses; it's the easiest way to identify a function in code.  The input(s) for a function or method go inside of those parentheses. \n",
    "\n",
    "In the code cell below, we call the `print()` function. Run the code in the cell below to see what `print()` does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Arguments** or **Parameters** - These are just the technical terms for the inputs that a function or method takes.  Some functions and methods require certain input(s), while others require no inputs. In the code cell above `'Hello world!'` is the argument for `print()`.<br><br>\n",
    "\n",
    "* **Library** - A library is a collection of code that defines certain methods and may also define the nature of special data types, like `datetime` objects made to calculate or track dates and times. When you need to use a particular method or special data type, you just import that library into the Python script you are writing.  Where do libraries come from?  They are written by programmers and shared with others, usually online.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Square'></a>\n",
    "\n",
    "### 1.6.3. Guided Exercise: Finding the Square Root\n",
    "\n",
    "In the cell below, try to use the square root function, `sqrt()`, from the math library to find the square root of a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations on your first of many error messages! Error messages are friendly. They tell you what went wrong so you know what to fix in your code. Error messages won't harm or break your script, but Python will stop executing code when it throws an error message. The `NameError` tells us that Python does not know what `sqrt()` is. Why? Because `sqrt()` is from the math library and we did not import that library yet. To use `sqrt()`, we just need to import the Math Library using a special command: `import`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Run this code by holding Ctrl and hitting Enter ##\n",
    "import math\n",
    "\n",
    "math.sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `sqrt()` is available inside our script, but notice you have to type it as `math.sqrt()` because even though we imported the Math Library we still have to tell Python where to find the `sqrt()` method. This syntax of `library_name.method_name()` is what you will use when you want to use methods from libraries. \n",
    "\n",
    "Also, notice that the word `import` shows up bold green in the code cell above while the word `math` is in normal black text. This is because `import` is a reserved word, or keyword, in Python.  Reserved words are words that are already assigned some special purpose and cannot be used for other things, like variable names or function names. You will learn more reserved words and what they do throughout this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Resources'></a>\n",
    "\n",
    "### 1.6.4. Python Resources\n",
    "\n",
    "**Online Resources**\n",
    "* [Python.org](https://www.python.org/)\n",
    "* [Python for Non-programmers](https://wiki.python.org/moin/BeginnersGuide/NonProgrammers)\n",
    "* [The Hitchhikers Guide to Python](http://docs.python-guide.org/en/latest/)\n",
    "* [PEP8 Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)\n",
    "    \n",
    "* [O'Reilly's Think Python: How To Think Like a Computer Scientist, 2nd Edition](http://greenteapress.com/thinkpython2/thinkpython2.pdf) - Allen Downey made this great introduction to Python 2.7 available for free at Green Tea Press. Should you decide to do the practical exercises in the book, Mr. Downey has made the [solutions](http://greenteapress.com/thinkpython/code/) available as Jupyter Notebooks.\n",
    "\n",
    "* [Automate the Boring Stuff with Python - Practical Programming for Total Beginners](https://automatetheboringstuff.com/) - Written for office workers, students, administrators, and anyone who uses a computer to learn how to code small, practical programs to automate tasks on their computer.\n",
    "\n",
    "* [StackOverflow](https://stackoverflow.com/questions/tagged/python) - A great resource to find solutions for any coding problem you might have in this course and in your jobs. If you find yourself stuck with a problem during the practical exercises, think about the problem you are trying to solve and ask Google. You will most likely find that you are not the first to have the problem and there are plenty of people out in the StackOverflow community who can help.\n",
    "\n",
    "* [Jupyter Notebook (software)](https://jupyter.org/) - The classroom exercises will be conducted using Jupyter Notebooks. Jupyter Notebooks, or iPython Notebooks as they were called previously, are a great way to create code, add documentation, and share both the code and the results with others.\n",
    "* [What is Jupyter Notebook (YouTube)](https://video.search.yahoo.com/search/video;_ylt=A0LEVxT2upRZU94AX1tXNyoA;_ylu=X3oDMTEyNGJkYnFqBGNvbG8DYmYxBHBvcwMxBHZ0aWQDQjQ0ODJfMQRzZWMDc2M-?p=jupyter+notebook+tutorial&fr=dss_yset_chr#id=8&vid=74d3ef639eeabb387d6267364dab002b&action=view)\n",
    "* [Jupyter Notebook Users Manual](https://athena.brynmawr.edu/jupyter/hub/dblank/public/Jupyter%20Notebook%20Users%20Manual.ipynb)\n",
    "* Cheat Sheets on the CSCI2011 course website\n",
    "* CSCI2011 Course Blog/Parking Lot\n",
    "\n",
    "**Offline Resources**\n",
    "* Python's `help()` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Keywords'></a>\n",
    "\n",
    "### 1.6.5. Reserved Keywords and Built-In Functions\n",
    "\n",
    "#### 1.6.5.1. Keywords\n",
    "#### References:\n",
    "* [Python: Keywords](https://docs.python.org/3.4/library/keyword.html)\n",
    "\n",
    "Reserved words, or keywords, are words within Python that have specific use cases and cannot be used as variable names. They show up as green and bold inside Jupyter Notebook code cells. The keyword library has a list of all Python's keywords. Run the cell below to print them out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the above words are not usable as variable names or for any other purpose than their specific functions. However, remember that Python is case sensitive. It is possible, for instance, to use `Elif` instead of `elif` as a variable name, but it is generally considered bad practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.6.5.2. Built-In Functions\n",
    "\n",
    "You will also notice that some words show up as light green (as opposed to bold green) when you type them into a code cell.  These are built-in functions (i.e., functions that come prepackaged for you with your version of Python).  \n",
    "\n",
    "Here are some examples of built-in functions.\n",
    "```python\n",
    "print()\n",
    "type()\n",
    "max()\n",
    "```\n",
    "\n",
    "Unlike reserved words, Python will let you re-assign built-in function names to other values, <i>but you should not do this</i>. Once you re-assign a function's name to something else, you lose the ability to use that function, which is bad because these functions are fundamental to some core Python capabilities. Never do something like the following. If you're ever creating a variable and the variable name turns green, choose a different name.\n",
    "\n",
    "**Do not do this:**\n",
    "```python\n",
    "print = 'message'\n",
    "list = [1, 2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Help'></a>\n",
    "\n",
    "### 1.6.6. Python's `help()` Function\n",
    "\n",
    "Python includes an interactive `help()` function, which initializes a help menu. If an argument is passed into the `help()` function (such as `math`), the documentation for that topic will be printed. The `help()` function works with imported libraries as well as keywords and built-in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help('keywords')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id=\"AdvJupyter\"></a>\n",
    "\n",
    "## 1.7. Jupyter Notebook Tips and Tricks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Notebooks'></a>\n",
    "\n",
    "### 1.7.1. Keyboard Shortcuts\n",
    "\n",
    "These notebooks can be very helpful as you navigate this course. Let's check out some of the functionality built into Jupyter Notebooks. There are a number of keyboard shortcuts that work in Jupyter Notebook. You can find a complete list of shortcuts by clicking the keyboard button in the menu above. The following three shortcuts are very useful because they allow you to run, or execute, cells.\n",
    "\n",
    "<br>\n",
    "<center> **Keyboard Shortcuts for All Modes**</center>\n",
    "\n",
    "| Shortcut | Description|\n",
    "|---|---|\n",
    "| Shift + Enter| Execute the contents of the cell, and move onto the next cell |\n",
    "| Ctrl + Enter | Execute the contents of the cell, but stay with this cell|\n",
    "| Alt + Enter | Execute the contents of the cell, insert a new cell below|\n",
    "\n",
    "**Exercise:** Run the code cell below using a keyboard shortcut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Good job!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you're using Jupyter Notebook, you're operating in one of two modes: _Edit Mode_ (green cell margin) and _Command Mode_ (blue cell margin). Edit Mode allows you to change the contents of a cell, whereas Command Mode allows you to perform operations on a cell or group of cells as a whole, such as running, copying, or deleting. To enter Edit Mode, either click inside the cell or hit Enter when the cell is highlighted. To enter Command Mode, either click outside of the cell or hit Escape.\n",
    "\n",
    "<center>**Keyboard Shortcuts for Switching Between Modes**</center>\n",
    "\n",
    "| Shortcut | Description|\n",
    "|:---:|---|\n",
    "| Enter | enter Edit Mode |\n",
    "| Esc | enter Command Mode |\n",
    "\n",
    "Jupyter also supports _Tab Completion_. This feature will complete certain code snippets for you, and is mostly used for completing variable and function names. Tab Completion is useful because it allows you to type code faster and prevents typos. \n",
    "\n",
    "**Exercise:** In the code cell below, a variable is created for you.  If you have to type this variable name with some frequency, that can get cumbersome.  Start to type the variable name in the cell below, then hit Tab to complete it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "very_long_variable_name = 'test string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>**Keyboard Shortcuts for Command Mode**</center>\n",
    "\n",
    "| Shortcut | Description|\n",
    "|:---:|---|\n",
    "| m | Convert a cell to Markdown|\n",
    "| y | Convert a cell to Code|\n",
    "| l | Show line numbers in the selected cell|\n",
    "| a | Insert a cell above the selected cell|\n",
    "| b | Insert a cell below the selected cell|\n",
    "| c | Copy the selected cell|\n",
    "| x | Cut the selected cell|\n",
    "| v | Paste cell below the selected cell|\n",
    "| dd | Delete selected cell |\n",
    "| z | Undo a cell deletion |\n",
    "| Up Arrow | Highlight the cell above |\n",
    "| Down Arrow | Highlight the cell below|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Change the cell type of the cell below. Once you change it to a code cell, try running it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#Change the type of this cell from Markdown to Code and run the cell.\n",
    "#You can do this by using the toolbar or the keyboard shortcuts.  Try both.\n",
    "\n",
    "print('Nice Job!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Delete one of the duplicated cells below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This cell is in here twice, get rid of one of them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This cell is in here twice, get rid of one of them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** In case you accidentally delete a code or markdown cell you've been working hard on, you *can* undo it. Undo the deletion from above. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add a code cell below, copy and paste the following line, then run it:\n",
    "```python\n",
    "print(\"Woah! You're getting the hang of this!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Try out Jupyter Notebook functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Try some code ideas here ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Try some code ideas here ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Try some code ideas here ##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Try some code ideas here ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "If you want a more in-depth review of Jupyter Notebooks and how you can customize them, check out the excellent [Jupyter Notebook Users Manual](https://athena.brynmawr.edu/jupyter/hub/dblank/public/Jupyter%20Notebook%20Users%20Manual.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='Kernel'></a>\n",
    "\n",
    "### 1.7.2. The Kernel Menu\n",
    "\n",
    "Under the hood, Jupyter Notebook has a Python _kernel_ that stores the variables you've created and remembers what libraries you've imported.  The kernel can only run one code cell at a time, but everything stored in the kernel is available anywhere inside your Jupyter Notebook. Splitting up code into different cells allows you to view outputs at every step. For example, the variable we create in the first cell below is still available to us in the second cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_variable = 'Test String'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(string_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kernels can break, and when they do we need to restart them. Let's break our kernel on purpose and walk through how to restart it. Run the code cell below.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the `[*]` next to the cell. When you see an asterisk in the brackets next to a cell, it means that cell is running. Sometimes, this is because the code is taking a while to complete, but this cell is waiting for an input in the dialog box, and until it gets that input it will hang there, waiting.\n",
    "\n",
    "![](./GRAPHICS/runningCell.png)\n",
    "\n",
    "When a cell is finished executing its code, you'll know because a number will appear in the brackets next to the cell. That number shows the order in which you ran the cells in this notebook. An empty set of brackets next to a code cell means it hasn't been run in the current kernel.\n",
    "\n",
    "![](./GRAPHICS/finishedCell.png)\n",
    "\n",
    "Now run the above cell again. Because we ran the cell while it was still waiting on user input, it will never stop. Now we have to restart the kernel. \n",
    "\n",
    "![](./GRAPHICS/kernel.png)\n",
    "\n",
    "Go to the \"Kernel\" dropdown at the top, and click \"Restart and Clear Output\".  You'll see a popup; select \"Restart and Clear Output\" in the popup. Wait until the `[*]` disappears. Let's try to reference our variable from before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(string_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Restarting the kernel means that all the previously stored memory is lost. If we need to access variables we created earlier in the script, we'll need to scroll up and rerun the cells that initialize them.\n",
    "\n",
    "**Exercise:** Re-run the code cell that initializes the `string_variable` above, then run the code cell directly above to print it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='output'></a>\n",
    "\n",
    "### 1.7.3. Output vs. `print()`\n",
    "\n",
    "In Jupyter Notebooks, there are two ways to display output:\n",
    "1. Type what you want to display inside the `print()` function.\n",
    "2. Type what you want to display as the last line in a code cell.\n",
    "\n",
    "Both ways are demonstrated in the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'A message'\n",
    "\n",
    "print(text)\n",
    "\n",
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if what you are trying to display is not on the last line of the code cell, it will not be displayed. `print()`, on the other hand, will display what you ask it to regardless of where the print statement is in the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'A message'\n",
    "\n",
    "text\n",
    "\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell above, we moved the last line of the previous code cell so that it is no longer the last line. We see the print statement still works as expected, but the other output has disappeared."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ComputationalThinking\"></a>\n",
    "<hr>\n",
    "\n",
    "## 1.8. Computational Thinking\n",
    "\n",
    "Computers are not smart, but they are fast. They need explicit instructions in order to solve a problem. This means that when we, as programmers, are presented with a problem, we have to provide the computer a complete set of instructions for it to do what we want. This requires a special mode of reasoning that we call *computational thinking*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./GRAPHICS/IconKeyPoster.png\" width=\"90%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic steps for approaching a problem with computational thinking are:\n",
    "\n",
    "1. **Decomposition:** Breaking down data, processes, or problems into smaller, manageable parts\n",
    "    1. Make sure you understand the problem\n",
    "        1. Identify the inputs\n",
    "        2. Identify what the output should look like\n",
    "    2. If it’s a large scale problem, identify possible smaller components\n",
    "<br><br>    \n",
    "2. **Pattern Recognition:** Observing patterns, trends, and regularities in data\n",
    "    1. Inspect your data\n",
    "        1. Make sure the inputs and outputs you’ve identified make sense\n",
    "        2. Look for trends or possible fringe cases\n",
    "<br><br>       \n",
    "3. **Abstraction:** Identifying the general principles that generate these patterns\n",
    "    1. Work out a problem by hand\n",
    "    2. As you work out by hand, attempt to think beyond a single example\n",
    "<br><br>\n",
    "4. **Algorithm Design:** Developing the step by step instructions for solving the problem\n",
    "    1. Begin to formalize your steps into pseudocode\n",
    "    2. Identify available software tools\n",
    "        1. These may be available packages, things you’ve written in the past, or built-in python functionality\n",
    "    3. Implement your pseudocode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <a id=\"compt_ge\"></a>\n",
    "\n",
    "### 1.8.1. Guided Exercise: Apply Computational Thinking\n",
    "\n",
    "Given the paragraph below, identify which sentence has the most words in it.  \n",
    "```python\n",
    "'''Security has been tightened in Kenya ahead of a controversial re-run of the presidential election which is being boycotted by the main opposition. Kenya's President Uhuru Kenyatta, who is seeking a second term, has urged people to vote and remain peaceful. Opposition leader Raila Odinga, who has pulled out of the election re-run, has called on his supporters to boycott it. Mr. Kenyatta was announced the winner in an 8 August vote but the poll is being held again because of \"irregularities\".'''\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1. Decomposition\n",
    "\n",
    "The first step to tackling any problem is to make sure you understand it, and break it down into smaller, more manageable parts. All computational problems have some input and some output.  Our solution is going to start with our input and produce the output we want. \n",
    "\n",
    "In this example problem, our input is a paragraph. In this case, an example paragraph is given to us, but the great thing about coding is that even if the input changes (i.e., if we're given a _new_ paragraph), re-applying an algorithm is easy. What is the output we want? We've been asked to identify the longest sentence in a paragraph.  The output will be the sentence with the most words.\n",
    "\n",
    "This problem has one major task, but we can break it up into smaller tasks to make algorithm design easier. After we accept the input, we need a way to split it up into individual sentences, count the words in each sentence, and determine which one has the most."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2. Pattern Recognition\n",
    "\n",
    "Looking at our example paragraph, what can we use to divide it into sentences?  What can we use to divide each sentence into words so we can count them? \n",
    "\n",
    "Here we should start thinking about _fringe cases_. While most English sentences end with a period, sometimes they also end with an exclamation point (\"!\") or a question mark(\"?\"). On the other hand, a period does not always denote the end of a sentence. For example, it could be part of a decimal number (2.15) or an abbreviation, such as \"Mr.\" As you can see, fringe cases appear when the first approach we think of is too broad or too narrow.\n",
    "\n",
    "**Fringe Cases:** These appear when our approach is either...\n",
    "- Too Broad: Our rule captures cases we don't want it to capture\n",
    "- Too Narrow: Our rule fails to capture cases we want it to capture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3. Abstraction\n",
    "\n",
    "We've been given an example to work through. But we want our solution to work for other similar inputs. That means our solution shouldn't depend on features of the example paragraph that might not appear in other valid paragraphs. We can use any patterns and fringe cases we identified in the last step to help us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4. Algorithm Design\n",
    "\n",
    "Designing an algorithm starts with writing something called _pseudocode_. Pseudocode is a detailed yet human-readable description of what a computer program or an algorithm must do. It is written in natural language instead of a programming language, but nonetheless captures the same logical steps. In this case, our pseudocode might look something like this.\n",
    "\n",
    "**Pseudocode:**\n",
    "1. Split the paragraph by periods to separate sentences\n",
    "2. For each sentence:\n",
    "    1. Count how many words are in the sentence\n",
    "    2. Compare the word count with the longest sentence you've seen so far\n",
    "    3. If it's the longest sentence, hold on to it, otherwise move to the next sentence\n",
    "3. Finally, print out the longest sentence and its word count\n",
    "\n",
    "Run through the pseudocode by hand with your example, and make sure it works like you'd expect. We haven't yet covered the the tools available to you in Python, but if you know of any tools that will be helpful, your pseudocode is a good place to note that. We haven't taught you how to code yet, but here's what our algorithm would look like in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paragraph = \"\"\"Security has been tightened in Kenya ahead of a controversial re-run of the presidential\n",
    "election which is being boycotted by the main opposition. Kenya's President Uhuru Kenyatta, who is seeking a \n",
    "second term, has urged people to vote and remain peaceful. Opposition leader Raila Odinga, who has pulled out \n",
    "of the election re-run, has called on his supporters to boycott it. Mr. Kenyatta was announced the winner in \n",
    "an 8 August vote but the poll is being held again because of \"irregularities\".\"\"\"\n",
    "\n",
    "## 1. Split the paragraph on \".\"\n",
    "sentences = paragraph.split(\".\")\n",
    "\n",
    "longest_sentence = \"\"\n",
    "\n",
    "## 2. For each sentence...\n",
    "for sentence in sentences:\n",
    "    \n",
    "    ## 2A-B. Count words and compare to the longest sentence we've seen so far\n",
    "    if len(sentence.split(\" \")) > len(longest_sentence.split(\" \")):\n",
    "        \n",
    "        ## 2C. If it's the longest, hold on to it\n",
    "        longest_sentence = sentence + \".\" #\n",
    "\n",
    "## 3. Finally, print the longest sentence and its word count\n",
    "print(len(longest_sentence.split(\" \")))\n",
    "print(longest_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<a id='PracticePython'></a>\n",
    "\n",
    "## 1.9. Practice Python\n",
    "\n",
    "Let's get some practice with Python basics before we end the lesson. But first, consider this foundational concept of coding in general. \n",
    "\n",
    "<hr>\n",
    "\n",
    "### 1.9.1. Hard-Coding vs. Programmatic Coding\n",
    "\n",
    "Hard-coding is when you type explicit values in your code. *Programmatic coding*, on the other hand, is using variables wherever possible. By writing programmatic code, you make your scripts useful to others as well as yourself. For example, let's say we write a script that approximates the cost of hosting a conference for a given number of people, with set expenses per person. With 50 attendees, our code could look something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_conf_cost = 50 * 8.00 + 50 * 1.50 + 50 * 14.25 + 50 * 0.75 + 50 * 10.00\n",
    "\n",
    "print('Number of attendees:', 50)\n",
    "print('Cost of conference:', total_conf_cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we received a late addition to our list of attendees. This requires that we adjust the code in at least six separate locations, and remember what each number's significance is in real life.<br><br>What would happen if the price of one component of the conference changed? What if the calculations were more complex? What if another number in the calculation was the same as the number of attendees?<br><br>Let's try pulling out the number of attendees and storing it as a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_attendees = 51\n",
    "\n",
    "cost_box_lunch = num_attendees * 8.00\n",
    "cost_drinks = num_attendees * 1.50\n",
    "cost_tshirt = num_attendees * 14.25\n",
    "cost_icecream = num_attendees * 0.75\n",
    "cost_goody_bags = num_attendees * 10.00\n",
    "\n",
    "total_conf_cost = cost_box_lunch + cost_drinks + cost_tshirt + cost_icecream + cost_goody_bags\n",
    "print('Number of attendees:', num_attendees)\n",
    "print('Cost of conference:', total_conf_cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine this is part of a larger, more complicated script in which you use the number of attendees two dozen times in various ways. Coding programmatically by storing the value to a variable allows us to make changes much faster and makes our code much less error-prone in the long run. Now our code is a little more robust thanks to our smart use of variables. But what if we wanted to find the cost of hosting a conference for a group of 500? If we're hard-coding, we'd have to go in a swap in `500` everywhere we see the value `51` in our code above. This is doable with only a few changes here, but what if our script used that attendee value in a hundred other places? Do you trust yourself to remember to swap every single value in your code? Better question: Why even bother if you can use a variable to do it for you?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <a id='variables'></a>\n",
    "\n",
    "### 1.9.2. Storing Values In Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Store two numbers inside two different variables. Subtract one number from the other using the minus sign (`-`). Multiply them together using Python's multiplication operator (`*`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** In Python, a text-based data point is called a string. Strings in Python are wrapped in quotation marks (`\"\"`). Store a string in a variable, then use the `print()` function to print it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The formula for finding the area of a circle with a given radius is below, but the cell below will throw an error because `r` is not defined. Create a variable `r` that stores a radius of your choice then use the code below to find the area of a circle with that radius. After you get it to work, change the value of your radius variable and run it again. You should see a different output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##\n",
    "PI = 3.14\n",
    "\n",
    "area = PI * r ** 2\n",
    "\n",
    "area"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The `len()` function in Python finds the length of something. When called on some text, it will return the number of characters the text is made up of. Use it by putting some text or a variable that holds some text into the parentheses, like so:\n",
    "```python\n",
    "len(some_text)```\n",
    "\n",
    "Create a variable that holds some text. Then use the `len()` function to find the length of it. After getting that to work, change the text that your variable holds and run the code again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Python can capture the concept of true and false. In coding, these are called Boolean values, and in Python they are capitalized like `True` and `False`. Store a Boolean value in a variable and print it using `print()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Python scripts can also store multiple data values in a single object called a list. You can make a list by wrapping any number of data values in a set of square brackets. Each value must be separated by a comma, like so:\n",
    "```python \n",
    "my_list = [1, 2, 3, 4, 5, 6]```\n",
    "\n",
    "Create your own list of values and store it to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The `len()` function works on lists too. Call the `len()` function on the list you just created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## YOUR CODE GOES HERE ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <a id='appendix'></a>\n",
    "\n",
    "## 1.10. Appendix\n",
    "\n",
    "<center> <b>Jupyter Notebook Shortcuts</b></center>\n",
    "\n",
    "| Shortcut | Description|\n",
    "|:---:|---:|\n",
    "| Shift + Enter| Execute the contents of the cell, and move to the next cell |\n",
    "| Ctrl + Enter | Execute the contents of the cell, but stay with this cell|\n",
    "| Alt + Enter | Execute the contents of the cell, insert a new cell below|\n",
    "| Enter | enter Edit Mode |\n",
    "| Esc | enter Command Mode |\n",
    "| m | Convert a cell to Markdown|\n",
    "| y | Convert a cell to Code|\n",
    "| l | Display line numbers in the selected cell|\n",
    "| a | Insert a cell above the selected cell|\n",
    "| b | Insert a cell below the selected cell|\n",
    "| c | Copy the selected cell|\n",
    "| x | Cut the selected cell|\n",
    "| v | Paste cell below the selected cell|\n",
    "| dd | Delete selected cell |\n",
    "| z | Undo a cell deletion |\n",
    "| Up Arrow | Highlight the cell above |\n",
    "| Down Arrow | Highlight the cell below|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> <b><center>UNCLASSIFIED</center></b>"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}