Lect1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1\n",
    "\n",
    "## Outline of topics for this lecture:\n",
    "\n",
    "1. Brief history of python\n",
    "2. Python's place in the family of programming languages\n",
    "3. Basic variables (integer, float, string)\n",
    "4. Conversions between the basic variable types\n",
    "5. Boolean variables\n",
    "6. \"Collection\" data types\n",
    "    a. lists\n",
    "    b. tuples\n",
    "    c. sets\n",
    "    d. dictionaries\n",
    "7. Operators\n",
    "8. Control statements\n",
    "9. Functions\n",
    "\n",
    "## In lab later on the assigned work is:\n",
    "\n",
    "1. Watch tutorials on github, sign up for a github account, and make a copy of (a.k.a., fork) a repo which will allow you to run the neccessary python code in a jupyter notebook.\n",
    "2. Write a script to read a file from disk, rename it, and write it back out with an extra line at the end.\n",
    "3. Write a function to test whether a particular word is present in a disk file or not and return `True` or `False` depending on the case.\n",
    "4. Read a csv file from disk and find the historical corn yield data in preparation for plotting the corn yield trend in the United States.\n",
    "\n",
    "## Some useful background material:\n",
    "\n",
    "The <a href=\"https://the-examples-book.com/book/introduction\" target=\"_blank\">Purdue Data Mine Examples Book</a> contains many useful chapters on data science. While they have not been directly designed for this class, they may be useful. You will not need to use scholar to perform the exercises of this class so don't worry about that part. Here is a direct link to the <a href=\"https://the-examples-book.com/book/python/introduction\" target=\"_blank\">Python chapter.</a>\n",
    "\n",
    "\n",
    "Additional useful links for Python include:\n",
    "\n",
    "<a href=\"https://docs.python.org/3/\" target=\"_blank\">Python 3.9.4 documentation</a>\n",
    "\n",
    "The <a href=\"https://pypi.org/\" target=\"_blank\">Python Package Index</a> (This contains many of the useful Python \"add-on\" packages such as the math package)\n",
    "\n",
    "The <a href=\"https://numpy.org/\" target=\"_blank\">Numpy Package</a> (This contains specialized array (vector and matrix) routines. Numpy stands for \"Numerical Python\")\n",
    "\n",
    "United States Department of Agriculture: <a href=\"https://quickstats.nass.usda.gov/\" target=\"_blank\">Quick Stats</a> (The USDA's National Ag Statistics Service -- go here and familiarize yourself with the available data)\n",
    "\n",
    "You will need to use Git and Github to get the example code for the class. Some useful tutorial links are:\n",
    "\n",
    "<a href=\"https://www.youtube.com/watch?v=USjZcfj8yxE\" target=\"_blank\">Learn Git in 15 Minutes</a> (Colt Steele)\n",
    "\n",
    "<a href=\"https://www.youtube.com/watch?v=USjZcfj8yxE\" target=\"_blank\">Learn Github in 20 Minutes</a> (Colt Steele)\n",
    "\n",
    "It makes sense to create a free github account for yourself: <a href=\"https://github.com/\" target=\"_blank\">Github</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## History of Python, Etc.\n",
    "\n",
    "- Conceived by Guido van Rossum in December 1989 at the Center Wiskunde and Informatica (Dutch national research institute for mathematics and computer science).\n",
    "- Python version 1.0 in January 1994.\n",
    "- GNU General Public License (open source) since version 1.6.1.\n",
    "- Python version 2.0 in October 2000.\n",
    "- Python Software Foundation formed in 2001 and a new open source license.\n",
    "- Python version 2.7 was the last release in the version 2 series. Support ended January 2020.\n",
    "-Python version 3.0 released December 2008. It broke backward compatibility with much of the verson 2 code.\n",
    "- Latest version is 3.10 (October 2021)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## According to stackoverflow survey of profession software developers ...\n",
    "\n",
    "<img align=\"left\" src='Figs/DeveloperSurvey2021.png' width=\"500\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## As concerns languages for data science ...\n",
    "\n",
    "The contenders are Python and R. For **Python**\n",
    "\n",
    "* Most popular among data scientists.\n",
    "* Very useful in machine learning and artificial intelligence because of the availabilty of popular libraries such as scikit-learn, matplotlib, and tensorflow, etc.\n",
    "\n",
    "For **R**\n",
    "\n",
    "* A scripting language.\n",
    "* Very good support for statistical computation and visulalization.\n",
    "\n",
    "This course is focussed on Python instead of R because that is a better for the work of my research group. For an independent comparison of the two: <a href=\"https://www.ibm.com/cloud/blog/python-vs-r\" target=\"_blank\">Python vs. R: What's the Difference?</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic variables\n",
    "\n",
    "Python uses something called **dynamic typing**, which means that a variable is created when a value is assigned to it. The type can be changed after originally set. There are a few rules on variable names:\n",
    "\n",
    "* Must start with a letter or underscore\n",
    "* Names are case-sensitive\n",
    "\n",
    "A python variable is more than just its value. It must also contain information about the type of the value. There is overhead associated with such flexibility. The code below illustrates three of the variable types: **integer, float, and string**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'int'>\n",
      "\n",
      "The value of x is:\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Integer, i.e., whole numbers both positive and negative. Later on \n",
    "# we will illustrate formatting the print command.\n",
    "x = 4;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print() # Just to give a space.\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'float'>\n",
      "\n",
      "The value of x is:\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "# Floating point, i.e., computer representation of real numbers.\n",
    "x = 4.0;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print() # Just to give a space.\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'str'>\n",
      "\n",
      "The value of x is:\n",
      "four\n"
     ]
    }
   ],
   "source": [
    "# Strings. A string is a sequence of characters. They can be delimited\n",
    "# by single quotes ('blah') or double quotes (\"blah blah\")\n",
    "x = \"four\"\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print() # Just to give a space.\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversions\n",
    "Python has a built-in command `float()` that can convert integers and certain strings to floating point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'int'>\n",
      "\n",
      "The value of x is:\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Start with an int.\n",
    "x = 4;\n",
    "\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print()\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'float'>\n",
      "\n",
      "The value of x is:\n",
      "4.0\n"
     ]
    }
   ],
   "source": [
    "# Convert to float\n",
    "x = float(x)\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print()\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'str'>\n",
      "\n",
      "The value of x is:\n",
      "1.67\n"
     ]
    }
   ],
   "source": [
    "# Can also convert strings representing floating point numbers to\n",
    "# float.\n",
    "x = '1.67'\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print()\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'float'>\n",
      "\n",
      "The value of x is:\n",
      "1.67\n"
     ]
    }
   ],
   "source": [
    "# Note that when we print the string version of x it prints it just\n",
    "# as if it were a floating point number, i.e., we can't tell from the\n",
    "# output.\n",
    "x = float(x)\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print()\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also a python command `int()`, which can covert floats to integer and certain strings to integer, and a command `str()`, which converts numbers to strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean type\n",
    "A Boolean value has a python type **bool**. The possible values a Boolean variable can take are: **True** and **False**. These are typically used to hold the results of logical tests, which in turn can be used to control the flow of a python program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of x is:\n",
      "<class 'bool'>\n",
      "\n",
      "The value of x is:\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = True;\n",
    "print('The type of x is:')\n",
    "print(type(x))\n",
    "print()\n",
    "print('The value of x is:')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collection data types\n",
    "There are four **collection** data types: **lists**, **tuples**, **sets**, and **dictionaries**. (Some say that a **string** is a collection data type since it is a ordered set of characters). For now we will only consider lists and sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u>Lists</u> are ordered, changeable, and allow duplicate members:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of Coloradothings is:\n",
      "<class 'list'>\n",
      "\n",
      "The length of Coloradothings is:\n",
      "5\n",
      "\n",
      "The value of Coloradothings is:\n",
      "['wheat', 'corn', 'sugar beets', 'pinto beans', 1959]\n"
     ]
    }
   ],
   "source": [
    "# Create a list with 5 elements.\n",
    "Coloradothings = [\"wheat\", \"corn\", \"sugar beets\", \"pinto beans\", 1959]\n",
    "print('The type of Coloradothings is:')\n",
    "print(type(Coloradothings))\n",
    "print()\n",
    "print('The length of Coloradothings is:')\n",
    "print(len(Coloradothings))\n",
    "print()\n",
    "print('The value of Coloradothings is:')\n",
    "print(Coloradothings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Coloradothings[3] ...\n",
      "pinto beans\n",
      "<class 'str'>\n",
      "\n",
      "For Coloradothings[4] ...\n",
      "1959\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# The elements inside of Coloradothings may be of differing\n",
    "# types ...\n",
    "print('For Coloradothings[3] ...')\n",
    "print(Coloradothings[3])\n",
    "print(type(Coloradothings[3]))\n",
    "print()\n",
    "print('For Coloradothings[4] ...')\n",
    "print(Coloradothings[4])\n",
    "print(type(Coloradothings[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['wheat', 'corn', 'sugar beets', 'pinto beans', 1959, 'Amherst']\n",
      "\n",
      "['wheat', 'corn', 'sunflowers', 'sugar beets', 'pinto beans', 1959, 'Amherst']\n"
     ]
    }
   ],
   "source": [
    "# We can append to a list and insert in a list\n",
    "\n",
    "Coloradothings.append(\"Amherst\")\n",
    "print(Coloradothings)\n",
    "print()\n",
    "Coloradothings.insert(2, \"sunflowers\")\n",
    "print(Coloradothings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <u>Sets</u> are unordered, changeable (in the sense that we can add and remove items from sets). Sets do not allow duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "{'Ag and Bio Engineering', 'Gene Keady', 'students', 'Ross-Ade Stadium', 'professors', 'study sessions'}\n",
      "\n",
      "Ag and Bio Engineering\n",
      "Gene Keady\n",
      "students\n",
      "Ross-Ade Stadium\n",
      "professors\n",
      "study sessions\n",
      "\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Make a set.\n",
    "Purduethings = {\"Ag and Bio Engineering\", \"Ross-Ade Stadium\", \"students\", \"professors\", \"Gene Keady\", \"study sessions\"}\n",
    "print(type(Purduethings))\n",
    "print(Purduethings) # Note the order it prints\n",
    "print()\n",
    "\n",
    "for x in Purduethings: # Note the order with which the for loop executes\n",
    "    print(x)\n",
    "\n",
    "print()\n",
    "print(\"Ag and Bio Engineering\" in Purduethings)\n",
    "print(\"Medical School\" in Purduethings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the code output above we note:\n",
    "1. The order in which we included the set items when defining it is not the order that python used to enumerate the items when printing. Just FYI.\n",
    "2. The statement in the last print command: `\"Ag and Bio Engineering\" in Purduethings` is a Boolean variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform classical set operations (**union**, **intersection**, **difference**, **test subset**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Purduethings union IUthings equals:\n",
      "{'Ag and Bio Engineering', 'Bobby Knight', 'Gene Keady', 'Hoosiers', 'students', 'Ross-Ade Stadium', 'professors', 'study sessions', 'parties'}\n",
      "\n",
      "Purduethings intersection IUthings equals:\n",
      "{'students', 'professors'}\n",
      "\n",
      "IUthings not also in Purduethings equals:\n",
      "{'Bobby Knight', 'parties', 'Hoosiers'}\n",
      "\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Make another set ...\n",
    "IUthings = {\"Hoosiers\", \"Bobby Knight\", \"students\", \"professors\", \"parties\"}\n",
    "print('Purduethings union IUthings equals:')\n",
    "print(Purduethings.union(IUthings))\n",
    "print()\n",
    "print('Purduethings intersection IUthings equals:')\n",
    "print(Purduethings.intersection(IUthings))\n",
    "print()\n",
    "print('IUthings not also in Purduethings equals:')\n",
    "print(IUthings.difference(Purduethings))\n",
    "print()\n",
    "print({\"Gene Cernan\",}.issubset(Purduethings))\n",
    "Purduethings.add(\"Gene Cernan\")\n",
    "print({\"Gene Cernan\",}.issubset(Purduethings))\n",
    "\n",
    "#print(Purduethings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic operators: +, -, *, /, %, **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "2\n",
      "35\n",
      "1.4\n",
      "2\n",
      "16807\n"
     ]
    }
   ],
   "source": [
    "# Arithmetic operators: +, -, *, /, %, **\n",
    "\n",
    "print(7 + 5)  # addition\n",
    "print(7 - 5)  # subtraction\n",
    "print(7 * 5)  # multiplication\n",
    "print(7 / 5)  # division\n",
    "print(7 % 5)  # remainder upon integer division\n",
    "print(7 ** 5) # exponentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment operators: =, +=, -=, *=, /=, **="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "5\n",
      "25\n",
      "5.0\n",
      "3125.0\n"
     ]
    }
   ],
   "source": [
    "# Assignment operators: =, +=, -=, *=, /=, **=\n",
    "\n",
    "b = 5\n",
    "a = b\n",
    "print(a)\n",
    "a += b # shorthand for a = a + b\n",
    "print(a)\n",
    "a -= b # shorthand for a = a - b\n",
    "print(a)\n",
    "a *= b # shorthand for a = a*b\n",
    "print(a)\n",
    "a /= b # shorthand for a = a/b\n",
    "print(a)\n",
    "a **= b # shorthand for a = a**b\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison operators: ==, !=, <, <=, >, >="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Comparison operators: ==, !=, <, <=, >, >=\n",
    "\n",
    "a = 3\n",
    "b = 2\n",
    "\n",
    "print(a == b)\n",
    "print(a != b)\n",
    "print(a < b)\n",
    "print(a <= b)\n",
    "print(a > b)\n",
    "print(a >= b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical operators: and, or, not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "False\n",
      "\n",
      "<class 'bool'>\n",
      "True\n",
      "\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Logical operators: and, or, not\n",
    "\n",
    "x = (a == b) # The expression a == b it a Boolean value (either True or False).\n",
    "             # The assignment creates a Boolean variable x\n",
    "print(type(x))\n",
    "print(x)\n",
    "\n",
    "print()\n",
    "\n",
    "y = not(x)\n",
    "print(type(y))\n",
    "print(y)\n",
    "\n",
    "print()\n",
    "\n",
    "z = True\n",
    "\n",
    "print(x or z)\n",
    "print(x and z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control statements\n",
    "There are three methods of program control that we consider here:\n",
    "1. If/else statement\n",
    "2. For loops\n",
    "3. While loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "# Example if/else statement\n",
    "\n",
    "a = 5;\n",
    "b = 3;\n",
    "if b > a:\n",
    "    print(\"b is greater than a\")\n",
    "elif a == b:\n",
    "    print(\"a and b are equal\")\n",
    "else:\n",
    "    print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# While loop: Execute while condition is true.\n",
    "\n",
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n",
      "\n",
      "\n",
      "Try continue command\n",
      "\n",
      "\n",
      "b\n",
      "a\n",
      "a\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# For loop: Iterate over a sequence. Also, have break (stop a loop where it is \n",
    "# and exit) and continue (move to the next iteration of loop).\n",
    "\n",
    "for x in \"banana\":\n",
    "    print(x)\n",
    "    \n",
    "print(\"\\n\")    \n",
    "print(\"Try continue command\")\n",
    "print(\"\\n\")\n",
    "\n",
    "for x in \"banana\":\n",
    "    if x == \"n\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "   \n",
    "Function are blocks of code that run when called. \n",
    "\n",
    "- Can pass parameters to a function. \n",
    "- A function can return a value.\n",
    "\n",
    "Functions allow code to be more readable by allowing the hiding of details of an operation that may not be central to the understanding of the overall algorithm. Sometimes, this is called encapsulation. For example, perhaps we want to solve some sort of geometric problem, such as finding the height of a tree from the angle of the sun and the length of the shadow cast on the ground. The height calculation will involve intermediate calculations of trigonometric functions of the angle (e.g., sine, cosine, tangent). These sorts of intermediate calculations are naturally left to functions in python and other programming languages.\n",
    "\n",
    "In addition, functions ...\n",
    "\n",
    "- Assist in divide and conquer problem solving.\n",
    "- Allow to reuse the function code in other parts of a larger program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Useful Function Example\n",
    "\n",
    "According to wikipedia this algorithm goes back to the Babylonians (100 AD) and is widely used for computing square roots by hand. The idea is this. If we want to find the square root of a positive number, say $Z$, we first start with a guess $x$ hoping $x^2 \\approx Z$. Now if the original guess is too large, i.e., $x^2 > Z$ then $x > Z/x$ and so we could move in the correct direction (towards smaller values of $x$) by making a new guess equal to the average of $x$ and $Z/x$, i.e.,\n",
    "\n",
    "New guess = $(x + Z/x)/2$.\n",
    "\n",
    "If, on the other hand, the original quess was too small, i.e., $x^2 < Z$ then $x < Z/x$ and using the above formula for the new guess would move in the correct direction of larger values. The algorithm is implemented in python in the function code below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hand calculation example ...\n",
    "\n",
    "Say Z = 10 and guess x = 3 for the square root. Then the next guess is the average of 3 and 3.3333..., which is approximately 3.16666... The next step in the algorithm gives an estimate of\n",
    "\n",
    "3.1622"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0.9450000000000001\n",
      "0.9433994708994708\n",
      "0.9433981132066374\n",
      "0.9433981132056604\n",
      "0.9433981132056604\n",
      "0.9433981132056604\n",
      "0.9433981132056604\n"
     ]
    }
   ],
   "source": [
    "Z = .89;\n",
    "x = [1, 1, 1, 1, 1, 1, 1, 1];\n",
    "N = len(x);\n",
    "print(x[0])\n",
    "i = 1;\n",
    "while i < N:\n",
    "    x[i] = (x[i-1] + Z/x[i-1])/2\n",
    "    print(x[i])\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Z is the positive number for which we want the square root. epsilon\n",
    "# is the tolerance in the accuracy of the result.\n",
    "\n",
    "def Newtroot(Z,epsilon):\n",
    "    x = 1\n",
    "    xp = (x + Z/x)/2\n",
    "    e = (xp - x)/x\n",
    "    while (e > epsilon) or (-epsilon > e):\n",
    "        x = xp\n",
    "        xp = (x + Z/x)/2\n",
    "        e = (xp - x)/x\n",
    "    return xp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of the square root algorithm\n",
    "\n",
    "z = 10\n",
    "epsilon = 1e-12\n",
    "\n",
    "print(Newtroot(z,epsilon))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The math package\n",
    "Python provides many modules designed for specialized programming tasks. See: <a href=\"https://pypi.org\" target=\"_blank\">The Python Package Index</a>.\n",
    "\n",
    "The math package contains trigonometric, exponential, logarithmic, hyperbolic, and special functions. It also contains a number of useful constants such as `pi` and `e`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "P = math.pi;\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the math package to create something interesting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This short program will print a table with 50 rows where\n",
    "# each row contains an argument and the sine of the argument.\n",
    "# The sine function will trace on complete period of length\n",
    "# 2*pi.\n",
    "N = 50;\n",
    "for k in range(N):\n",
    "    t = 2*P*k/N;\n",
    "    print(t, math.sin(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table above is difficult to read because it is not well formatted. Python has tools to simplify formating with the print command. There is a nice explanation in the Data Mind notes mentioned in the introduction. One prefered method uses `f-strings`, which stands for **format string**. They are indicated by preceeding the string with `f` or `F`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare two ways of printing pi\n",
    "print('The value of pi is approximately', P)\n",
    "print()\n",
    "print(f'The value of pi is approximately {math.pi:.3f}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a prettier (more readable) sinewave table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prettier sine wave table.\n",
    "N = 50;\n",
    "for k in range(N):\n",
    "    t = 2*P*k/N;\n",
    "    print(f'{t: 1.2f}', '  ', f'{math.sin(t): .3f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The NumPy Package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All data manipulated by a computer is represented in binary. In otherwords, via one method or another, all data -- temperature sensor readings, hourly barometric pressure from your Davis weather station, an audio file, images from your Bushnell game camera, a yield map -- are represented as arrays of numbers.\n",
    "\n",
    "**NumPy (Numerical Python)** provides an efficient interface to store and compute on dense data buffers. NumPy arrays are much more efficient than Python's built-in list data type.\n",
    "\n",
    "See: <a href=\"http://www.numpy.org\" target=\"_blank\">The Numpy Package</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the numpy package. This command allows us to refer to numpy\n",
    "# commands using the shorthand \"np\".\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting examples with Matplotlib\n",
    "A better way to plot. Who says there has been no progress in the world since 1970?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import matplotlib and define a shorthand\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n",
    "y = np.array([3, 1, 6, 5, 4, 11, -1, 1, 2, 6]);\n",
    "\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "plt.style.use('classic')\n",
    "plt.plot(x, y)\n",
    "plt.title(\"Example Plot\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "fig2 = plt.figure()\n",
    "plt.style.use('seaborn-dark-palette')\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.plot(x, np.cos(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## United states wheat yield trends as a plotting example ...\n",
    "\n",
    "Data was obtained from the United States Department of Agriculture: <a href=\"https://quickstats.nass.usda.gov/\" target=\"_blank\">Quick Stats</a> (The USDA's National Ag Statistics Service -- we will make more use of this in the lab later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The years for which we have average wheat yield data.\n",
    "dates = np.array([2021, 2020, 2019, 2018, 2017, 2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006, 2005, 2004, 2003, 2002, 2001, 2000,1999, 1998, 1997, 1996, 1995, 1994, 1993, 1992, 1991, 1990, 1989, 1988, 1987, 1986, 1985, 1984, 1983, 1982, 1981, 1980, 1979, 1978, 1977, 1976, 1975, 1974, 1973, 1972, 1971, 1970, 1969, 1968, 1967,1966, 1965, 1964, 1963, 1962, 1961, 1960, 1959, 1958, 1957, 1956, 1955, 1954, 1953, 1952, 1951, 1950, 1949, 1948, 1947, 1946, 1945,1944, 1943, 1942, 1941, 1940, 1939, 1938, 1937, 1936, 1935, 1934, 1933, 1932, 1931, 1930, 1929, 1928, 1927, 1926, 1925, 1924, 1923,1922, 1921, 1920, 1919, 1918, 1917, 1916, 1915, 1914, 1913, 1912,1911, 1910, 1909, 1908, 1907, 1906, 1905, 1904, 1903, 1902, 1901,1900, 1899, 1898, 1897, 1896, 1895, 1894, 1893, 1892, 1891, 1890,1889, 1888, 1887, 1886, 1885, 1884, 1883, 1882, 1881, 1880, 1879,1878, 1877, 1876, 1875, 1874, 1873, 1872, 1871, 1870, 1869, 1868, 1867, 1866])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The average wheat yield data in the order to line up with the corresponding years.\n",
    "yields = np.array([44.5, 49.7, 51.7, 47.6, 46.4, 52.7, 43.6, 43.7, 47.1, 46.2, 43.6, 46.1, 44.3, 44.8, 40.2, 38.6, 42. , 43.2, 44.2, 35. , 40.2, 42. , 42.7, 43.2, 39.5, 36.3, 35.8, 37.6, 38.2, 39.3, 34.3, 39.5, 32.7, 34.1, 37.7, 34.4, 37.5, 38.8, 39.4, 35.5, 34.5, 33.5, 34.2, 31.4, 30.7, 30.3, 30.6, 27.3, 31.6, 32.7, 33.9, 31. , 30.6, 28.4, 25.8, 26.3, 26.5, 25.8, 25.2, 25. , 23.9, 26.1, 21.6, 27.5, 21.8, 20.2, 19.8, 18.1, 17.3, 18.4, 16. , 16.5, 14.5, 17.9, 18.2, 17.2, 17. , 17.7, 16.4, 19.5, 16.8, 15.3, 14.1, 13.3, 13.6, 12.8, 12.2, 12.1, 11.2, 13.1, 16.3, 14.2, 13. , 15.4, 14.7, 14.7, 12.8, 16. , 13.3, 13.8, 12.7, 13.5, 12.9, 14.8, 13.2, 11.9, 16.7, 16.1, 14.4, 15.1, 12.4, 13.7, 15.5, 14.3, 14.2, 16. , 15.2, 12.9, 13.7, 14.9, 15. , 12.2, 12.5, 15.2, 14. , 12.8, 13.9, 13.5, 12.4, 14.2, 16.5, 12.2, 14. , 12.1, 13.3, 14.1, 11.4, 14.8, 12.3, 15.1, 11. , 13.2, 13. , 13.5, 14.1, 10.9, 11.1, 13. , 12.9, 11.8, 12.2, 12.1, 13.7, 12.9, 12.6, 11. ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the wheat yield trend\n",
    "fig = plt.figure()\n",
    "plt.style.use('classic')\n",
    "plt.plot(dates, yields)\n",
    "plt.title(\"United States Average Wheat Yield by Year\")\n",
    "plt.xlabel(\"Year\")\n",
    "plt.ylabel(\"Yield in bushels per acre\")\n",
    "plt.grid()"
   ]
  },
  {
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}