intro_coding.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import os\n",
    "from numpy import array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ANACONDA INSTALLATION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# https://docs.anaconda.com/anaconda/install/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![python](https://mfr.osf.io/export?url=https://osf.io/3xzd5/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+python1.png&parentUrl=https://osf.io/3xzd5/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![disclaimer](https://mfr.osf.io/export?url=https://osf.io/u25vq/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+disclaimer.png&parentUrl=https://osf.io/u25vq/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![data](https://mfr.osf.io/export?url=https://osf.io/xzsny/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+data_types.png&parentUrl=https://osf.io/xzsny/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **PRIMATIVES**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Integers, Floats, Strings, and Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers are values represented as whole numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int1 = 1 #whole number\n",
    "\n",
    "print(type(int1)) # The type() function allows us to the data type of a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floats are values represented as decimals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float1 = 1.0 #decimal number\n",
    "\n",
    "print(type(float1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings are sequences of characters -- letters, numbers, and/or symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = 'hello_world' #characters in quotes\n",
    "\n",
    "print(type(string1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean values are binary, representing \"True\" and \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value1 = True\n",
    "value2 = False\n",
    "\n",
    "print(type(value1))\n",
    "print(type(value2))\n",
    "\n",
    "# Booleans are most often used in conditional statements or while loops to indicate when a process should begin or end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **NON-PRIMATIVES**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *-- LISTS VS ARRAYS: SIMILARITIES & DIFFERENCES --*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## - LISTS -\n",
    "\n",
    "* Variables containing an ordered group of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8]\n",
    "list1.append(10) #add 10 to the end of the list\n",
    "print('It can change!', list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexable \n",
    "* Can be used to isolate specific values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![index](https://qph.fs.quoracdn.net/main-qimg-a380b1bc159589df5e0b9842e5b56b6d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "item1 = list2[3]\n",
    "item2 = list2[-5]\n",
    "\n",
    "print('Select the same item in list2', item1, item2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sliceable\n",
    "* Multiple values within a list can be selected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list3 = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "slice_list3 = list3[2:-2] #use both types of index methods to grab list values 3 - 6\n",
    "print('Select multiple specific values', slice_list3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterable\n",
    "* Using a loop, individual values can be used 1 (or more) at a time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list4 = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "for i in list4:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists _do not_ allow arithmetic operations on elements\n",
    "\n",
    "* If one tries, the following error will be returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list4 = [1,2,3,4,5,6,7,8]\n",
    "\n",
    "list4_half = list4/2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## - ARRAYS -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Allow you to do everything as with lists, BUT ALSO MATH!! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = array([1,2,3,4,5,6,7,8]) #array method surrounds the bracketed list, converting into an array\n",
    "\n",
    "divided_array = array1/2.\n",
    "print('We can divide!', divided_array)\n",
    "\n",
    "multiplied_array = array1*2.\n",
    "print('We can multiply!', multiplied_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can get as complicated as necessary..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "complex_array = array1*2/10. # Make sure to remember PEMDAS!\n",
    "\n",
    "print(complex_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ...but think carefully about the _structure_ of your data and how you _manipulate_ it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = array([1,2,3,4,5,6,7,8]) # these values are integers\n",
    "\n",
    "complex_array = array1*2/10 # the values you are using to change the array are integers too\n",
    "print(\"This doesn't seem right...\", complex_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### There's two easy ways to fix this...\n",
    "\n",
    "#1. Add a decimal to any of number used to change the array values\n",
    "#2. Use the float() method to convert the numerator/denominator to a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a decimal\n",
    "complex_array1 = array1*2/10.\n",
    "print('Adding a decimal works!', complex_array1)\n",
    "\n",
    "# Convert using float function\n",
    "complex_array2 = array1*2/float(10)\n",
    "print('Float method works too!', complex_array2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## - TUPLES -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples are collections of objects separated by commas, with or without parentheses\n",
    "* Lists are difference because the contents are surrounded by squarre brackets\n",
    "* Arrays have square brackets AND array()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = ('item1', 'item2') \n",
    "tuple2 = 'item1', 'item2'\n",
    "\n",
    "list1 = ['item1', 'item2'] \n",
    "array1 = array(['item1', 'item2']) \n",
    "\n",
    "print(type(tuple1))\n",
    "print(type(tuple2))\n",
    "print(type(list1))\n",
    "print(type(array1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples cannot be changed, unlike lists and arrays\n",
    "* Multiply with parentheses at creation\n",
    "* Cannot append new values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8]\n",
    "list1.append(10)\n",
    "print(list1)\n",
    "\n",
    "tuple1 = ('python',)*3\n",
    "print(type(tuple1))\n",
    "print(tuple1)\n",
    "\n",
    "tuple2 = (1,2,3,4,5,6,7,8)\n",
    "tuple2.append(10) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples can be added together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (1,2,3,4)\n",
    "tuple2 = ('A','B','C','D')\n",
    "new_mixed_object = tuple1 + tuple2\n",
    "print(new_mixed_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -- DICTIONARIES --"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a dictionary using curly brackets, keys, and values in square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'key1':[1,2,3,4,5], 'key2':[6,7,8,9,10], 'key3':[11,12,13,14,15]}\n",
    "\n",
    "print(type(dict1))\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Dictionaries are *not* naturally ordered\n",
    "* Ordered dictionaries can be created using the OrderedDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict \n",
    "\n",
    "dict1 = {'key1':[1,2,3,4,5], 'key2':[6,7,8,9,10], 'key3':[11,12,13,14,15]}\n",
    "\n",
    "keys = ['key1', 'key2', 'key3']\n",
    "list_of_tuples = [(key, dict1[key]) for key in keys] #list comprehension is awesome!!\n",
    "ordered_dict = OrderedDict(list_of_tuples)\n",
    "print(ordered_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Values can be accessed and/or changed by referencing the key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('original', ordered_dict['key1'])\n",
    "\n",
    "ordered_dict['key1'] = [21,22,23,24,25]\n",
    "print('edited', ordered_dict['key1'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specific items can be changed by referencing key and/or index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('complete key-value', ordered_dict['key2'])\n",
    "\n",
    "print('first item in key2', ordered_dict['key2'][0])\n",
    "print('first 4 items in key2', ordered_dict['key2'][0:4]) #you can slice just like lists and arrays!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### New key-value pairs can be added to an existing dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2 = {'key1':[1,2,3,4,5], 'key2':[6,7,8,9,10], 'key3':[11,12,13,14,15]}\n",
    "dict2['key4'] = [16,17,18,19,20]\n",
    "\n",
    "print(dict2)\n",
    "\n",
    "## If you add a new key-value pair to an ordered dictionary, it will be appended to the end and NOT ordered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can remove key-value pairs using the .pop method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2 = {'key1':[1,2,3,4,5], 'key2':[6,7,8,9,10], 'key3':[11,12,13,14,15]}\n",
    "\n",
    "print('original dict2', dict2)\n",
    "dict2.pop('key2')\n",
    "print('removing key2', dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PYTHON STATEMENT, INDENTATION, & COMMENTS\n",
    "* Before learning about loops, we need to understand how Python handles statements, blocks of code, and indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple assignment statement\n",
    "variable = 1\n",
    "\n",
    "print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-line statements, line breaks, and line continuation\n",
    "* Back slashes serve to break long lines of code into more readable pieces \n",
    "* a, b, and c return the same value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single line format\n",
    "a = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9\n",
    "\n",
    "# Line break format\n",
    "b = 1 + 2 + 3 + \\\n",
    "    4 + 5 + 6 + \\\n",
    "    7 + 8 + 9\n",
    "    \n",
    "# Line continuation\n",
    "c = (1 + 2 + 3 + 4 + 5 \n",
    "     + 6 + 7 + 8 + 9)\n",
    "    \n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How Python identifies blocks of code\n",
    "* Other languages, such as C++ and Java, use curly brackets to define blocks of code\n",
    "* Python uses indentation to organize code into coherent statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A block of code typically begins with a loop, conditional statment, or function definition\n",
    "* Everything indented below the first line is interpreted as belonging to the same block of code\n",
    "* Indentations are 4 spaces (or one tab) from the preceding line\n",
    "* Indented code below is executed each time the for loop runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for num in range(1,11): \n",
    "    print(num) #four spaces from for loop\n",
    "    if num == 5:\n",
    "        break #four spaces from if statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments\n",
    "* Comments are **life-savers** and the greatest gift you can give to your future selves\n",
    "## Comment _EVERYTHING_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://mfr.osf.io/export?url=https://osf.io/dvucw/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+comments.png&parentUrl=https://osf.io/dvucw/&format=2400x2400.jpeg\"\n",
    "     alt=\"commenting\"\n",
    "     style=\"float: left; width: 400px\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use # at the beginning of a new line to write a comment\n",
    "### You can also add a comment using # at the end of a line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loops through all colors and suits\n",
    "\n",
    "print(list1) #prints all values contained in list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-line comments\n",
    "* If your comments are longer than a single line, you can easily break them into multiple lines using multiple # or three single quotes (''' ''') or three double quotes (\"\"\" \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#According to all known laws of aviation, there is no way a bee should be able to fly. \n",
    "#Its wings are too small to get its fat little body off the ground.\n",
    "#The bee, of course, flies anyway because bees don't care what humans think is impossible. \n",
    "#Yellow, black. Yellow, black. Yellow, black. Ooh, black and yellow! Let's shake it up a little.\n",
    "\n",
    "'''\n",
    "According to all known laws of aviation, there is no way a bee should be able to fly. \n",
    "Its wings are too small to get its fat little body off the ground.\n",
    "The bee, of course, flies anyway because bees don't care what humans think is impossible. \n",
    "Yellow, black. Yellow, black. Yellow, black. Ooh, black and yellow! Let's shake it up a little.\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# LOOPS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## -- FOR LOOPS --\n",
    "* Allows code to iterate (repeat) over a sequence (list, tuple, dictionary, string, etc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple for loop over a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for this_fruit in fruits:\n",
    "    print(this_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple for loop over the letters in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for letter in \"banana\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Breaking for loops\n",
    "* Stop the loop before it has completed the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for this_fruit in fruits:\n",
    "    print(this_fruit) \n",
    "    if this_fruit == \"banana\":\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continuing for loops\n",
    "* Stop a current iteration and continue to the next element in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for this_fruit in fruits:\n",
    "    if this_fruit == \"banana\":\n",
    "        continue\n",
    "    print(this_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested for loops\n",
    "* Iteration through multiple lists\n",
    "* Loops 10 times (number of teams X number of mains)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teams = ['Red', 'Blue']\n",
    "mains = ['Heavy', 'Spy', 'Scout', 'Medic', 'Pyro']\n",
    "\n",
    "for this_team in teams:\n",
    "    for this_main in mains:\n",
    "        print(this_team, this_main)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enumeration of elements\n",
    "* Provides the index of the current item in the iteration (i.e. this_main)\n",
    "* Kinda like counting the number of times the loop iterates (starting at 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mains = ['Heavy', 'Spy', 'Scout', 'Medic', 'Pyro']\n",
    "\n",
    "for i, this_main in enumerate(mains):\n",
    "    print(i+1, this_main) #if 1 is added to i, it's just like counting!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## -- WHILE LOOPS --\n",
    "\n",
    "* Allows code to iterate (repeat) until a particular condition is met\n",
    "* Good for when the number of necessary iterations is unknown\n",
    "    * Counters and/or booleans are usually needed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple while loop with counter condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 0\n",
    "\n",
    "while counter < 5:\n",
    "    print(counter)\n",
    "    counter += 1  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple while loop with counter AND boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boolean = True\n",
    "counter = 0\n",
    "\n",
    "while boolean == True: #equivalent test\n",
    "    counter +=1\n",
    "    print(boolean)\n",
    "    if counter == 3:\n",
    "        boolean = False #reassignment\n",
    "        print(boolean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Breaking while loops\n",
    "* Terminate the while loop using **break**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 1\n",
    "while True: # it would go forever!\n",
    "    print(counter)\n",
    "    if counter == 3:\n",
    "        break # terminate once counter reaches 3\n",
    "    counter += 1  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Continuing while loops\n",
    "* Stop the current iteration and continue to the next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 0\n",
    "while counter < 6:\n",
    "    counter += 1 \n",
    "    if counter == 3:\n",
    "        continue #continue after counter reaches 3\n",
    "    print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## -- FROOT LOOPS --\n",
    "* Just tastes good"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![frooooooot](https://mfr.osf.io/export?url=https://osf.io/a7zrj/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+froot_loops.png&parentUrl=https://osf.io/a7zrj/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# CONDITIONAL STATEMENTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Operators\n",
    "* Operators that allow conditional statements to compare values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![comp ops](https://mfr.osf.io/export?url=https://osf.io/pxcqb/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+comparison_ops.png&parentUrl=https://osf.io/pxcqb/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## -- IF, ELIF, AND ELSE --"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 90\n",
    "letter = \"\"\n",
    "\n",
    "if grade >= 90:\n",
    "    letter = \"A\"\n",
    "elif grade >= 80:\n",
    "    letter = \"B\"\n",
    "elif grade >= 70:\n",
    "    letter = \"C\"\n",
    "elif grade >= 60:\n",
    "    letter = \"D\"\n",
    "else:\n",
    "    letter = \"F\"\n",
    "    \n",
    "print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using conditional statements in a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_grades = [75, 77, 56, 97, 87, 67, 92, 73, 88, 95]\n",
    "class_letters = []\n",
    "\n",
    "for grade in class_grades:\n",
    "    if grade >= 90:\n",
    "        letter = \"A\"\n",
    "    elif grade >= 80:\n",
    "        letter = \"B\"\n",
    "    elif grade >= 70:\n",
    "        letter = \"C\"\n",
    "    elif grade >= 60:\n",
    "        letter = \"D\"\n",
    "    else:\n",
    "        letter = \"F\"\n",
    "    class_letters.append(letter)\n",
    "print(class_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# ADDRESSING EXCEPTIONS (ERRORS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "![error types](https://mfr.osf.io/export?url=https://osf.io/mwvdf/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+error_types.png&parentUrl=https://osf.io/mwvdf/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BEGINNER EXERCISE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a short script to create a list containing all friendly mobs, then print it!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mobs = ['creepers', 'wolf', 'cat', 'zombie', 'skeleton', 'dolphin']\n",
    "behavior = [0,1,1,0,0,1] # 0 = hostile, 1 = friendly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://mfr.osf.io/export?url=https://osf.io/nhcem/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+arithmetic_ops.png&parentUrl=https://osf.io/nhcem/&format=2400x2400.jpeg\"\n",
    "     alt=\"commenting\"\n",
    "     style=\"float: left; width: 700px\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://mfr.osf.io/export?url=https://osf.io/pnurq/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+logical_ops.png&parentUrl=https://osf.io/pnurq/&format=2400x2400.jpeg\"\n",
    "     alt=\"commenting\"\n",
    "     style=\"float: left; width: 600px\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# -----------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![imports pic](https://mfr.osf.io/export?url=https://osf.io/4mj5c/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+imports.png&parentUrl=https://osf.io/4mj5c/&format=2400x2400.jpeg) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# NumPy \n",
    "## Library for scientific computing in Python\n",
    "## https://www.numpy.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### NumPy - IMPORTING - "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy #general importing\n",
    "import numpy as np # alias importing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy - IMPORTING SPECIFIC PACKAGES AND/OR TOOLS - "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random #import the entire random package\n",
    "\n",
    "print(1, numpy.random.random())\n",
    "print(2, np.random.random())\n",
    "print(3, random.random())\n",
    "\n",
    "from numpy.random import random #import only the specific random function within the random package\n",
    "print(4, random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy arrays are your friends\n",
    "* Allows simultaneous mathematical computations on the elements of an array\n",
    "* Easily reshapeable\n",
    "* Easily searchable\n",
    "* Gotta go _fast_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy arrays can be created in multiple dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://miro.medium.com/max/2000/1*Ikn1J6siiiCSk4ivYUhdgw.png\"\n",
    "     alt=\"commenting\"\n",
    "     style=\"float: left; width: 600px\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1_array = np.array([1, 2, 3]) #1D array\n",
    "print(type(D1_array))  \n",
    "print(D1_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D2_array = np.array([[1,2,3],\n",
    "                     [4,5,6]]) #2D array\n",
    "print(D2_array.shape)\n",
    "print(D2_array[0, 0], D2_array[0, 1], D2_array[1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When attempting to isolate a particular values, indices are like coordinates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![numpy example2](https://mfr.osf.io/export?url=https://osf.io/xundr/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+np_indexing.png&parentUrl=https://osf.io/xundr/&format=2400x2400.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Searching arrays using np.where()\n",
    "* Make a random 4x4 array and find all values greater than 0.5\n",
    "* Create variable to contain all indices in array1 greater than 0.5\n",
    "* Print greater_05 to review elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = random(size=(4,4))\n",
    "print(\"initial random array \\n\", array1)\n",
    "print(\"\")\n",
    "greater_05 = np.where(array1 > .5)\n",
    "print(\"indices for elements > 0.5 \\n\", np.vstack(greater_05).T)\n",
    "print(\"\")\n",
    "print(\"elements > 0.5 \\n\", array1[greater_05])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy provides functions to create populated arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zeros_array = np.zeros((2,3)) # Create an array of all zeros\n",
    "print(zeros_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array = np.ones((2,3))  # Create an array of all ones\n",
    "print(ones_array)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_array = np.full((2,3), 7)  # Create a constant array\n",
    "print(full_array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_array = np.random.random((2,3))  # Create an array filled with random values\n",
    "print(random_array)                     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"https://mfr.osf.io/render?url=https://osf.io/vd23n/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF%20%7C%20numpy_cheatsheet.pdf&parentUrl=https%3A%2F%2Fosf.io%2Fvd23n%2F\", width=1000, height=650)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# SciPy Stats\n",
    "## Even more math than NumPy! Fresh new inferential analyses!\n",
    "## https://docs.scipy.org/doc/scipy/reference/tutorial/stats.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"https://mfr.osf.io/render?url=https://osf.io/fpk28/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF%20%7C%20Python_SciPy_Cheat_Sheet_Linear_Algebra.pdf&parentUrl=https%3A%2F%2Fosf.io%2Ffpk28%2F\", width=1000, height=650)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats as stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# pandas -- Python Data Analysis Library\n",
    "## Dictionaries with all the mathematical functionality of NumPy!\n",
    "## https://pandas.pydata.org/pandas-docs/stable/reference/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://mfr.osf.io/export?url=https://osf.io/6dynk/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF+%7C+pandas.png&parentUrl=https://osf.io/6dynk/&format=2400x2400.jpeg\"\n",
    "     alt=\"commenting\"\n",
    "     style=\"float: left; width: 350px\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"https://mfr.osf.io/render?url=https://osf.io/v4bxa/?action=download%26mode=render%26direct%26public_file=True&initialWidth=684&childId=mfrIframe&parentTitle=OSF%20%7C%20pandas_cheatsheet.pdf&parentUrl=https%3A%2F%2Fosf.io%2Fv4bxa%2F\", width=1000, height=650)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}