Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax\n",
    "\n",
    "Python is an interpreted language and does not require a specific first or last line (such as `public static void main` in Java or `return` in C).\n",
    "\n",
    "There are no curly braces `{}` to define code blocks or semi-colons `;` to end a line. Instead of braces, indentation is rigidly enforced to create a block of code.\n",
    "\n",
    "Use a `#` symbol to create a comment\n",
    "\n",
    "Python supports the usual statements for conditional execution and loop execution, such as `if/elif/else`, `for`, `while`, etc. These type of statements end with a `:` and then follow with an indented block of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "This belongs to the _else_ case\n",
      "\n",
      "3>1\n",
      "This is not part of the _else_ case\n"
     ]
    }
   ],
   "source": [
    "# This is a comment\n",
    "\n",
    "if (3 < 2):\n",
    "    print(\"True\")# Another Comment.  This print syntax only works in Python 3, not Python 2\n",
    "    print(\"This is still in the _if_ case\")\n",
    "else:\n",
    "    print(\"False\")\n",
    "    print(\"This belongs to the _else_ case\")\n",
    "\n",
    "print()\n",
    "    \n",
    "if (3>1):\n",
    "    print(\"3>1\")\n",
    "else:\n",
    "    print(\"3<1\")\n",
    "    \n",
    "#Although not required, it is a good idea to leave a blank line after each block for readbility    \n",
    "print(\"This is not part of the _else_ case\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is less than 2\n"
     ]
    }
   ],
   "source": [
    "if 1 > 1:\n",
    "    print(\"1 is greater than 1\")\n",
    "elif 1 < 2:\n",
    "    print(\"1 is less than 2\")\n",
    "else:\n",
    "    print(\"This won't be printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like back in algebra 1, we are going to assign values to names that we call variables.  \n",
    "\n",
    "Common variable types in Python include integers, float (decimal values), and strings (alphanumeric sequences).\n",
    "\n",
    "Variables can be given alphanumeric names beginning with an underscore or letter.  Variable types do not have to be declared and are inferred at run time.  This is a marked differnce between Python and Java or C, where variable types must be declared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(type(a)) # Built in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b = 2.5 \n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be declared with either single or double quotes.  (So flexible, Python!)\n",
    "\n",
    "In general, Python tries to do the \"right thing\" when you operate on variable. Thus, if you use `+` on two strings, it does string concatenation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go Gators\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "c1 = \"Go \"\n",
    "c2 = 'Gators'\n",
    "c3 = c1 + c2\n",
    "print(c3)\n",
    "print(type(c3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scope of variables is local to the function, class, and file in that increasing order of scope.  Global variables can also be declared.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules and Import\n",
    "Files with a .py extension are known as Modules in Python.  Modules are used to store functions, variables, and class definitions.  \n",
    "\n",
    "Modules that are not part of the standard Python library are included in your program using the <code>import</code> statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'cos' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-5b8b9e4a0735>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# To use Math, we must import it\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcos\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'cos' is not defined"
     ]
    }
   ],
   "source": [
    "# To use Math, we must import it\n",
    "import math\n",
    "print(cos(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whoops.  Importing the `math` module allows us access to all of its functions, but we must call them in this way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(math.cos(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you can use the `from` keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "from math import cos\n",
    "print(cos(math.pi))# we only imported cos, not the pi constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `from` statement we can import everything from the math module.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "print(sin(pi/2)) # now we don't have to make a call to math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**This is strongly discouraged because you will eventually import 2 functions with the same name from different libraries and not even know which one you are calling! This is called namespace pollution**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "As you may expect, Python has a powerful, full featured string module.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go Gators, Come on Gators, Get up and go!\n"
     ]
    }
   ],
   "source": [
    "mystring = \"Go Gators, Come on Gators, Get up and go!\"\n",
    "print(mystring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Substrings\n",
    "Python strings can be substringed using bracket syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Come on Gators\n"
     ]
    }
   ],
   "source": [
    "print(mystring[11:25])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a 0-index based language.  Generally whenever forming a range of values in Python, the first argument is inclusive whereas the second is not, i.e. <code>mystring[11:25]</code> returns characters 11 through 24.\n",
    "\n",
    "You can omit the first or second argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go Gators\n"
     ]
    }
   ],
   "source": [
    "print(mystring[:9]) # all characters before the 9th index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get up and go!\n"
     ]
    }
   ],
   "source": [
    "print(mystring[27:]) # all characters at or after the 27th"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go Gators, Come on Gators, Get up and go!\n"
     ]
    }
   ],
   "source": [
    "print(mystring[:]) # you can even omit both arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using negative values, you can count positions backwards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "go\n"
     ]
    }
   ],
   "source": [
    "print(mystring[-3:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Structures\n",
    "### Lists\n",
    "The Python standard library does not have traditional C-style fixed-memory fixed-type arrays.  Instead, lists are used and can contain a mix of any type.\n",
    "\n",
    "Lists are created with square brackets `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'five']\n"
     ]
    }
   ],
   "source": [
    "mylist = [1, 2, 3, 4, 'five']\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be used as stacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'five', 6.0]\n"
     ]
    }
   ],
   "source": [
    "mylist.append(6.0) # add an item to the end of the list like push\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.0\n",
      "[1, 2, 3, 4, 'five']\n"
     ]
    }
   ],
   "source": [
    "popped = mylist.pop() # by default, the last item in the list is removed and returned\n",
    "print(popped)\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'five', 8, 'nine']\n"
     ]
    }
   ],
   "source": [
    "mylist.extend([8, 'nine']) # extend the list with the contents of another list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(len(mylist)) # returns the length of any iterable such as lists and strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# default list sorting. When more complex objects are in the list, arguments can be used to customize how to sort\n",
    "mylist = [9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
    "mylist.sort()\n",
    "print(mylist)\n",
    "\n",
    "# This is implace operation, return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "ans = mylist.sort()\n",
    "print(ans)\n",
    "print(type(ans))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "mylist.reverse() # reverse the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "Python includes the set data structure which is an unordered collection with no duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida State', 'Miami', 'Florida'}\n"
     ]
    }
   ],
   "source": [
    "schools = ['Florida', 'Florida State', 'Miami', 'Florida']\n",
    "myset = set(schools) # the set is built from the schools list\n",
    "print(myset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print('Georgia' in myset) # membership test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print('Florida' in myset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida'}\n"
     ]
    }
   ],
   "source": [
    "badschools = set(['Florida State', 'Miami'])\n",
    "print(myset - badschools) # set arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida State', 'Miami'}\n"
     ]
    }
   ],
   "source": [
    "print(myset & badschools) # AND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida State', 'Florida', 'Miami'}\n"
     ]
    }
   ],
   "source": [
    "print(myset | badschools) # OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida'}\n"
     ]
    }
   ],
   "source": [
    "print(myset ^ badschools) # XOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "Python supports dictionaries which can be thought of as an unordered list of key, value pairs.  Keys can be any immutable type and are typically integers or strings.  Values can be any object, even dictionaries.\n",
    "\n",
    "Dictionaries are created with curly braces `{}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida': 1, 'Georgia': 2, 'Tennessee': 3}\n"
     ]
    }
   ],
   "source": [
    "mydictionary = {'Florida' : 1, 'Georgia' : 2, 'Tennessee' : 3}\n",
    "print(mydictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(mydictionary['Florida']) # access the value with key = 'Florida'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida': 1, 'Georgia': 2}\n"
     ]
    }
   ],
   "source": [
    "del mydictionary['Tennessee'] # funky syntax to delete a key, value pair\n",
    "print(mydictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida': 1, 'Georgia': 7}\n"
     ]
    }
   ],
   "source": [
    "mydictionary['Georgia'] = 7 # assignment\n",
    "print(mydictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Florida': 1, 'Georgia': 7, 'Kentucky': 6}\n"
     ]
    }
   ],
   "source": [
    "mydictionary['Kentucky'] = 6 # you can append a new key\n",
    "print(mydictionary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Florida', 'Georgia', 'Kentucky'])\n"
     ]
    }
   ],
   "source": [
    "print(mydictionary.keys()) # get a list of keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Python supports for, foreach, and while loops\n",
    "### For loops\n",
    "Traditional counting loops are accomplished in Python with a combination of the <code>for</code> key word and the <code>range</code> function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for x in range(10): # with one argument, range produces integers from 0 to 9\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "for y in range(5, 12): # with two argumentts, range produces integers from 5 to 11\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "7\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for z in range(1, 12, 3): # with three arguments, range starts at 1 and goes in steps of 3 until greater than 12\n",
    "    print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for a in range(10, 1, -5): # can use a negative step size as well\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "for b in range(2, 1, 1): # with a positive step, all values are less than 1. No integers are produced\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in range(1, 2, -1): # same goes for a negative step as all values are less than 2\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While\n",
    "Python supports standard <code>while</code> loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 5\n",
    "\n",
    "while (a < b): \n",
    "    print(a)\n",
    "    a += 1 # example of incrementing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "Functions in Python do not have a distinction between those that do and do not return a value.  If a value is returned, the type is not declared.\n",
    "\n",
    "Functions can be declared in any module without any distinction between static and non-static.  Functions can even be declared within other functions\n",
    "\n",
    "The syntax is the following"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there!\n"
     ]
    }
   ],
   "source": [
    "def hello():\n",
    "    print(\"Hello there!\")\n",
    "    \n",
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#0 Kasey Hill\n"
     ]
    }
   ],
   "source": [
    "def player(name, number): # use some arguments\n",
    "    print( \"#\" + str(number), name) # cast number to a string when concatenating\n",
    "    \n",
    "player(\"Kasey Hill\", 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can have optional arguments if a default value is provided in the function signature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#0 Kasey Hill Florida\n"
     ]
    }
   ],
   "source": [
    "def player(name, number, team = 'Florida'): # optional team argument\n",
    "    print(\"#\" + str(number), name, team)\n",
    "    \n",
    "player(\"Kasey Hill\", 0) # no team argument supplied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#2 Aaron Harrison Kentucky\n"
     ]
    }
   ],
   "source": [
    "player(\"Aaron Harrison\", 2, \"Kentucky\") # supplying all three arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python functions can be called using named arguments, instead of positional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#23 Chris Walker Florida\n"
     ]
    }
   ],
   "source": [
    "player(number = 23, name = 'Chris Walker')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### return\n",
    "In Python functions, an arbitrary number of values can be returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "def sum(x,y):\n",
    "    return x + y # return a single value\n",
    "\n",
    "print(sum(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2\n"
     ]
    }
   ],
   "source": [
    "def sum_and_product(x,y):\n",
    "    return x + y, x * y # return two values\n",
    "\n",
    "mysum, myproduct = sum_and_product(1,2)\n",
    "print(mysum, myproduct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample Python Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# flip a fair coin n times, count results\n",
    "def coinFlip(n):\n",
    "    result = {'H' : 0,\n",
    "              'T' : 0}\n",
    "    for i in range(n):\n",
    "        if random.randint(0, 1) == 0:\n",
    "            result['H'] += 1\n",
    "        else:\n",
    "            result['T'] += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'H': 501100, 'T': 498900}\n"
     ]
    }
   ],
   "source": [
    "print(coinFlip(10 ** 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# row a 6-face-fair-die n times, count results\n",
    "def rollDie(n):\n",
    "    result = {i + 1 : 0 for i in range(6)}\n",
    "    for i in range(n):\n",
    "        result[random.randint(1, 6)] += 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1000864, 2: 1000360, 3: 999813, 4: 998957, 5: 1000140, 6: 999866}\n"
     ]
    }
   ],
   "source": [
    "print(rollDie(6 * 10 ** 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "This notebook is forked from the [Python workshops repo](https://github.com/dsiufl/Python-Workshops) hosted by [UF Data Science and Informatics(UF-DSI)](http://www.dsiufl.org)\n",
    "\n",
    "![DSI-logo](https://avatars0.githubusercontent.com/u/11587714?v=3&s=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}