Python 0-Instructor.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to Python 0 : An Introduction to Data Science\n",
    "\n",
    "Please sign in if you have not already. We use this data to improve our workshops!\n",
    "\n",
    "### About UF DSI\n",
    "\n",
    "We are an multi- and inter- disciplinary student organization that is dediated to promoting Data Science here at the Univeristy of Florida. We are partnered with the UF Informatics Institute who's aim is to foster informatics research and education.\n",
    "\n",
    "### What is Python?\n",
    "\n",
    "Python is an easy-to-use and robust **Object-Oriented** programming language. A lot of new software application are built with Python for this reason. It is used in other areas of computer science such and software engineering, digital arts, cybersecurity, and of course Data Science! \n",
    "\n",
    "This is a workshop that will introduce you to the basics of python and introduce you to Data Science and Visualization in Python. Due to the breadth of the language there are still many topics left for you to explore! Here we teach you the necessary skills. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculator\n",
    "\n",
    "Python can be used as a calculator. <code>Shift+Enter</code> runs the code block so you don't have to click run every time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition and Subtraction\n",
    "(3+2)-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplication and Division\n",
    "(3*2)/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exponentation\n",
    "3**6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "print(type(a)) # Built in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2.5 \n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be declared with either single or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = \"Go \"\n",
    "c2 = 'Gators'\n",
    "c3 = c1 + c2\n",
    "print(c3)\n",
    "print(type(c3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "As you may expect, Python has a powerful, full featured string module.  \n",
    "\n",
    "\n",
    "But what is a string?\n",
    "Strings are treated as individual characters strung together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch = 'This is a sample string'\n",
    "len(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Substrings\n",
    "Python strings can be substringed using bracket syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystring = \"Go Gators, Come on Gators, Get up and go!\"\n",
    "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring[:9]) # all characters before the 9th index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring[27:]) # all characters at or after the 27th"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring[-3:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Functions\n",
    "Here are some more useful string functions\n",
    "#### find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring.find(\"Gators\")) # returns the index of the first occurence of Gators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like nothing was found.  -1 is returned by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (mystring.find(\"Seminoles\")) # no Seminoles here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lower and upper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring.lower())\n",
    "print(mystring.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring.split()) # returns a list of strings broken by a space by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mystring.split(',')) # you can also define the separator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### join\n",
    "\n",
    "The <code>join</code> is useful for building strings from lists or other iterables.  Call <code>join</code> on the desired separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(' '.join([\"Go\", \"Gators\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on string functions:\n",
    "\n",
    "https://docs.python.org/2/library/stdtypes.html#string-methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "Python supports the standard if-else-if conditional expression. REMEMBER TO INDENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1; b = 2\n",
    "\n",
    "if a > b:\n",
    "    print (\"a is greater than b\")\n",
    "elif a < b:\n",
    "    print (\"a is less than b\")\n",
    "else:\n",
    "    print(\"a is equal to b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also combine conditionals using 'or' and 'and'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = -1\n",
    "t2 = 5\n",
    "\n",
    "if t1 > 0 and t2 > 0:\n",
    "    print (\"both are positive\")\n",
    "    \n",
    "if t1 > 0 or t2 > 0:\n",
    "    print(\"one of them is positive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Python supports for, foreach, and while loops\n",
    "### For (counting)\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(10): # with one argument, range produces integers from 0 to 9\n",
    "    print (x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "markdown",
   "metadata": {},
   "source": [
    "### Foreach\n",
    "As it turns out, counting loops are just foreach loops in Python.  The <code>range</code> function returns a list of integers over which <code>for in</code> iterates.  This can be extended to any other iterable type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in ['foo', 'bar']: # iterate over a list of strings\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While\n",
    "\n",
    "While loops aren't used nearly as frequently as for loops, here's the syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also force the loop to break using the break command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  if i == 3:\n",
    "    break\n",
    "  i += 1"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sayHello():\n",
    "    print (\"Hello there!\")\n",
    "    \n",
    "this = \"is to waste space\"\n",
    "sayHello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def player(name, number, team = 'Florida'): # optional team argument\n",
    "    print (\"#\" + str(number), name, team)\n",
    "    \n",
    "\n",
    "player(\"Kasey Hill\", 0) # no team argument supplied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(x,y):\n",
    "    return x + y # return a single value\n",
    "\n",
    "print(sum(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [1, 2, 3, 4, 'five']\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.append(6.0) # add an item to the end of the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.insert(6, 7) # insert the number 7 at index 6\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.remove('five') # removes the first matching occurence \n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(mylist)) # returns the length of any iterable such as lists and strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default list sorting. When more complex objects are in the list, arguments can be used to customize how to sort\n",
    "mylist.sort()\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.reverse() # reverse the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on Lists:\n",
    "\n",
    "https://docs.python.org/2/tutorial/datastructures.html#more-on-lists"
   ]
  },
  {
   "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": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# To use Math, we must import it\n",
    "import math\n",
    "print(cos(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whoops.  Importing the <code>math</code> module allows us access to all of its functions, but we must call them in this way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(math.cos(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you can use the <code>from</code> keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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 <code>from</code> statement we can import everything from the math module.  \n",
    "\n",
    "Disclaimer: many Pythonistas discourage doing this for performance reasons.  Just import what you need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from math import *\n",
    "print(sin(pi/2)) # now we don't have to make a call to math"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}