02_Intro_to_Python_Student.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A review of Python\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Check the Kernel you are using:</b> Before we get started, if you are running this on HiPerGator, double check the kernel in use. This is shown in the top right of the window and should look like: <img src=\"images/kernel.python310.png\" alt\"Image showing that the notebook is using the Python 3.10 kernel\" style=\"float:right\">\n",
    "</div>\n",
    "\n",
    "This notebook has been adapted from the [UF Data Science and Informatics](http://www.dsiufl.org/) [Python 0 workshop](https://github.com/dsiufl/Python-Workshops). \n",
    "\n",
    "**This notebook has placeholders for code to be netered during class.** If you want the completed version, see the [Intro_to_Python.ipynb file](Intro_to_Python.ipynb)--but try typing the code in during class, it is slower, but you will likely remember more.\n",
    "\n",
    "\n",
    "## About UF DSI--The original creators of this content [<img src=\"images/UF_DSI_logo.png\" alt=\"UF DSI Logo\" style=\"width: 200px;float:right\"/>](http://www.dsiufl.org/)\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",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Object Oriented Programming (or OOP)</b> is a popular paradigm in programming. Classes and the Objects created from them offer a level of abstraction that facilitates coding by compartmentalizing data and the methods that opperate on these data. Here are some resources for more information on OOP:\n",
    "    <ul>\n",
    "        <li><a href=\"https://www.freecodecamp.org/news/object-oriented-programming-concepts-21bb035f7260/\">How to explain object-oriented programming concepts to a 6-year-old</a><\\li>\n",
    "            <li><a href=\"https://github.com/comptoolsres/Jupyter_content/blob/main/py4e_ch14_ObjectOrientedProgramming.ipynb\">A Jupyter notebook with my notes on OOP for my Computational Tools class</a></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplication and Division\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exponentiation\n"
   ]
  },
  {
   "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.**\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Python is what is referred to as \"dynamically typed\", variables do have a type, but that type is inferred based on the data that the variable holds at any given time. This has advantages and disadvantages. Speed is one disadvantage--any operation on a variable needs to first determine the variable's type and then the appropriate opperation can be made.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be declared with either single or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Some things to try:\n",
    " * Practice making some variables of different types. \n",
    " * See what happens when you add, subtract, divide integers and floating point numbers. \n",
    " * Practice printing and formatting output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integers \n",
    "\n",
    "# Floats\n",
    "\n",
    "# Strings\n",
    "\n",
    "# Add two int variables\n",
    "\n",
    "# Add two float variables\n",
    "\n",
    "# Add an int and a float\n",
    "\n",
    "# Divide a int by a float\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run the line below for a solution\n",
    "# %load snippets/Ex_01.variables.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules and Import\n",
    "\n",
    "~~Files with a .py extension are known as Modules in Python.~~ By convention, Python scripts are saved with a `.py` file extension. A Module is little more than a Python script and its functions and class definitions can be imported into other scripts or notebooks. Modules are used to store functions, variables, and class definitions.  \n",
    "\n",
    "The Python language is intentionally limited in its functionality, with required features being added as needed.\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": {},
   "outputs": [],
   "source": [
    "# To use Math, we must import it\n"
   ]
  },
  {
   "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": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you can use the <code>from</code> keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "     # 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",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Disclaimer:</b> many Pythonistas discourage using <code>from ____ import *</code> for performance reasons and to avoid namespace conflicts.  <b>Only import what you need</b>. \n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "   # now we don't have to make a call to math--but this is lazy and not recommended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "As you may expect, Python has a powerful, full featured string module.  \n",
    "\n",
    "### Substrings\n",
    "Python strings can be substringed using bracket syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": [
    "   # all characters before the 9th index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # all characters at or after the 27th"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # 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": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2\n",
    "\n",
    "Write the code to print the substring Gators. You can use either occurence of the word in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run the line below for a solution\n",
    "#%load snippets/Ex_02.substring_Gators.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Functions\n",
    "Here are some more useful string functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lower and upper\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "<b>Note:</b> Referring back to the idea of OOP: classes and objects, a there is a string class and <code>mystring</code> is an object made from that class. The class has several methods, <code>.lower()</code> and <code>.upper()</code> are two methods of the string class and can be applied to the <code>mystring</code> object.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  # 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": [
    "  # no Seminoles here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # returns a list of strings broken by a space by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # 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": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on string functions:\n",
    "\n",
    "https://docs.python.org/3.8/library/stdtypes.html#string-methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Reading Documentation is an important skill. There are many string methods. Have a look over the [String Methods section of the Python documentation](https://docs.python.org/3.8/library/stdtypes.html#string-methods) and impliment two new methods, e.g. try the `.replace()` method or the `.swapcase()` method). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": [
    "    # Note that a list can have multiple variable types\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # add an item to the end of the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # insert the number 7 at index 6\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # removes the first matching occurence \n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "   # 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": [
    "  # 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",
    "\n",
    "\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  # reverse the list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information on Lists:\n",
    "\n",
    "https://docs.python.org/3.8/tutorial/datastructures.html#more-on-lists"
   ]
  },
  {
   "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": []
  },
  {
   "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": [
    " # with one argument, range produces integers from 0 to 9\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # 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": [
    " # iterate over a list of strings\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Let's combine conditionals and for loops. Write code to go through the integers from 0 to 10 and print \"Odd\" for odd numbers, \"Even\" for even numbers, \"Less than 5\" for numbers less than 5, \"Equals 5\" for 5, and \"Greater than 5\" for numbers greater than 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run the line below for a solution\n",
    "#%load snippets/Ex_04.loop_conditional.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are an important part of good coding. They help break your code into functional elements, making your code easier to write, read and maintain. This is one step of **abstraction**--allowing you to focus on relevant portions of code (e.g. we don't normally care *how* the `.upper()` method works, but if we do, we could look at the code). They help reduce repeated blocks of code. \n",
    "\n",
    "A function may or may not take input values and may or may not return output values. \n",
    "\n",
    "Functions need to be defined before they can be used. The definition syntax is the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def player(name, number): # use some arguments\n",
    "     # cast number to a string when concatenating\n",
    "    \n"
   ]
  },
  {
   "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": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "   # 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": []
  },
  {
   "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": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "Write a function that takes a number of years and calculates and prints how many days, hours, minutes and seconds that corresponds to and returns the nubmer of seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uncomment and run the line below for a solution\n",
    "#%load snippets/Ex_05.yearConvert_function.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Science Tutorial\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> We will return to look more at Pandas later, but this tutorial is a good introduction.</div>\n",
    "\n",
    "\n",
    "Now that we've covered some Python basics, we will begin a tutorial going through many tasks a data scientist may perform.  We will obtain real world data and go through the process of auditing, analyzing, visualing, and building classifiers from the data.\n",
    "\n",
    "We will use a database of selected professor salaries downloaded from a set of data made available by Vincent Arel-Bundock called [Rdatasets](https://vincentarelbundock.github.io/Rdatasets/). The specific file can be downloaded using this link: \n",
    "https://vincentarelbundock.github.io/Rdatasets/csv/carData/Salaries.csv\n",
    "\n",
    "## Obtaining the Data\n",
    "\n",
    "[`Pandas`](https://pandas.pydata.org/) is a powerful module for tabular data--much of the data we deal with!\n",
    "\n",
    "Using the `Pandas` library we can easily import data from a given link or from a file on our computer (must know syntax for filepath). In this case we will give it a link.\n",
    "\n",
    "In the code below, note that it is common to use aliases when importing modules to provide shorter names to reference them. In this case, Pandas is normally imported as `pd`. You could call it whatever you want, but it is best to stick with convention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd # import the module and alias it as pd\n",
    "\n",
    "salary_data = pd.read_csv('https://vincentarelbundock.github.io/Rdatasets/csv/carData/Salaries.csv')\n",
    "salary_data.head() # show the first few rows of the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets take a look at some simple statistics for the **yrs.since.phd** column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>salary_data.mean().round()</code> will take the mean of each column (this computation ignores the currently present `nan` values (not a number)), then round, and return a dataframe indexed by the columns of the original dataframe.\n",
    "\n",
    "This function can be used to replace all missing values with the mean of each column. In this tutorial however, we will not use this method, because the large number of missing values would greatly skew our standard deviations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check Unique Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Structurally, Pandas dataframes are a collection of Series objects sharing a common index.  In general, the Series object and Dataframe object share a large number of functions with some behavioral differences.  In other words, whatever computation you can do on a single column can generally be applied to the entire dataframe.\n",
    "\n",
    "Now we can use the dataframe version of <code>describe</code> to get an overview of all of our data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the Data\n",
    "Another important tool in the data scientist's toolbox is the ability to create visualizations from data.  Visualizing data is often the most logical place to start getting a deeper intuition of the data.  This intuition will shape and drive your analysis.\n",
    "\n",
    "Even more important than visualizing data for your own personal benefit, it is often the job of the data scientist to use the data to tell a story.  Creating illustrative visuals that succinctly convey an idea are the best way to tell that story, especially to stakeholders with less technical skillsets.\n",
    "\n",
    "We'll be using the plotting library matplotlib, which stands for mathematical plotting library. It is the most widely used plotting library, and has a few other packages built on top of it (like a library called seaborn) to make your plots even more beautiful and easy to use. \n",
    "\n",
    "We'll start by doing a bit of setup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing matplotlib library with an alias as well as the seaborn library\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set(style = 'darkgrid', color_codes = True)   # my personal style preferences\n",
    "\n",
    "# hack to make seaborn plots bigger on jupyter notebooks\n",
    "def setPlt():\n",
    "    f, ax = plt.subplots(figsize = (13,9))\n",
    "    sns.despine(f, left = True, bottom = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go ahead and start with a histogram of the years since the professors got their phd using the displot( ) function.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create our first plot, a histogram of salaries\n",
    "\n",
    "setPlt()\n",
    "hist = sns.distplot(salary_data['yrs.since.phd'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualization is all about asking questions of the data. One thing that we could be curious about is how the pay changes as people have had their phd for longer. We can make a scatterplot of exactly that using the scatter function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setPlt()\n",
    "scatplt = sns.scatterplot(x = 'yrs.since.phd', y = 'salary', data = salary_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the above does not work please follow these steps:\n",
    "\n",
    "MAC\n",
    "\n",
    "-Open terminal and type <code>conda remove seaborn</code> and press Enter. \n",
    "    \n",
    "-Then type <code>conda install seaborn==0.9.0</code>\n",
    "\n",
    "    \n",
    "Windows\n",
    "\n",
    "-Open Anaconda Prompt (Press Windows button and type \"Anaconda Prompt\")\n",
    "    \n",
    "-Type <code>conda remove seaborn</code>\n",
    "    \n",
    "-Then type <code>conda install seaborn==0.9.0</code>\n",
    "\n",
    "You may need to restart anaconda "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seems like there are some people who have had their Ph.D for a while but still dont get paid a lot. Does the same hold true with how long they've worked? What about their position?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setPlt()\n",
    "sns.scatterplot(x = 'yrs.service', y = 'salary' ,data = salary_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also color our graph fairly easily, let's compare the years since Phd to the Years of employement to see the distribution of salary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#colored scatter plot\n",
    "setPlt()\n",
    "sns.scatterplot(x = 'yrs.since.phd', y = 'salary', hue = 'rank', data = salary_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "So far in our three-part Python series (check out DSI's [Python 1](https://github.com/dsiufl/Python-Workshops/tree/master/Python1) and [Python 2](https://github.com/dsiufl/Python-Workshops/tree/master/Python2) modules for more), we've learned about variables, data structures, functions, and graphing. While we have introduced these topics in the context of data science with Python, they are central to programming in any language and in any context.\n",
    "\n",
    "\n",
    "### Data Science in a Nutshell\n",
    "We believe that data science has the potential to revolutionalize the way we understand our world. Anyone can learn the tools of Data Science in order to ensure success. Our goal is to give you these tools and create a community of data scientists here at UF.\n",
    "\n",
    "We hope you enjoed the workshop and look forward to seeing you soon!\n",
    "\n",
    "#### Visit our website if you want to get involved with DSI:  http://www.dsiufl.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thank You !"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "UFRC Python-3.10",
   "language": "python",
   "name": "python3-3.10-ufrc"
  },
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}