Foundational_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Foundational Python\n",
    "This notebook covers the first two days of Python instruction for Data in Social Context (9/10-12/2018) by [Chreston Miller](mailto:chmille3@vt.edu), University Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Python can be used as a calculator\n",
    "9 + 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "936"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#use shift-enter to run a cell\n",
    "4* 234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#variables are data associated with a name\n",
    "#here the variable name is 'weight_kg' and the value is 60\n",
    "weight_kg = 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'weight' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-1f176f0d1671>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#variables can also reference strings\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m#qoutes (single or double) tell Python it's a string, not a name\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mweight_kg_text\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mweight\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mkilograms\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'weight' is not defined"
     ]
    }
   ],
   "source": [
    "#variables can also reference strings\n",
    "#qoutes (single or double) tell Python it's a string, not a name\n",
    "weight_kg_text = weight in kilograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#oops - let's try it with qotes\n",
    "weight_kg_text = \"weight in kilograms\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65.0\n"
     ]
    }
   ],
   "source": [
    "#print displays values and/or strings\n",
    "print(weight_kg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in kilograms 65.0\n"
     ]
    }
   ],
   "source": [
    "#combine two variables in one print (the comma makes a space)\n",
    "print(weight_kg_text, weight_kg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in pounds: 132.0\n"
     ]
    }
   ],
   "source": [
    "#numeric variables can be used in mathematical expressions\n",
    "print('weight in pounds:',2.2 * weight_kg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n"
     ]
    }
   ],
   "source": [
    "#without changing the underlying variable\n",
    "print(weight_kg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in kilgrams is now: 65.0\n"
     ]
    }
   ],
   "source": [
    "#variables can be reassigned (to a new value)\n",
    "weight_kg = 65.0\n",
    "print('weight in kilgrams is now:', weight_kg)\n",
    "#if you ran the weight in pounds now, the answer would reflect this change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word = 'lead'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n"
     ]
    }
   ],
   "source": [
    "#a string is stored as a vector of characters\n",
    "#\"0\" is the first position in python, so this call will print the 4th letter\n",
    "print(word[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-5303631aa0ce>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mword\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m#oops - we got an error because there is no word[4]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#it only has 4 letters\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m#use the error type and text to figure out what went wrong\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "print(word[4])\n",
    "#oops - we got an error because there is no word[4]\n",
    "#it only has 4 letters\n",
    "#use the error type and text to figure out what went wrong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l\n",
      "e\n",
      "a\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "word = 'lead'\n",
    "#a for loop allows you to do the same action with each part of a vector\n",
    "for char in word:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l\n",
      "Hello World\n",
      "e\n",
      "Hello World\n",
      "a\n",
      "Hello World\n",
      "d\n",
      "Hello World\n",
      "l\n",
      "e\n",
      "a\n",
      "d\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "word = 'lead'\n",
    "#Python uses indentation to scope loops\n",
    "#anything indented under a loop will run once for each item\n",
    "for char in word:\n",
    "    print(char)\n",
    "    print(\"Hello World\")\n",
    "#watch what happens if we move it outside the loop\n",
    "for char in word:\n",
    "    print(char)\n",
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l\n",
      "e\n",
      "a\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "#python doesn't care if what we call something makes sense\n",
    "#but it will help you later if it does\n",
    "word = 'lead'\n",
    "for banana in word:\n",
    "    print(banana)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 vowels\n"
     ]
    }
   ],
   "source": [
    "length = 0\n",
    "#you can interact with a variable's value using expressions\n",
    "for vowel in 'aeiou':\n",
    "    length = length + 1\n",
    "print('There are',length,'vowels')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "after the loop, letter is c\n"
     ]
    }
   ],
   "source": [
    "#using a name in a loop assigns that variable, even if it already exists\n",
    "letter = 'z'\n",
    "for letter in 'abc':\n",
    "    print(letter)\n",
    "print('after the loop, letter is',letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odds are: [1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "#use brackets and commas to make a list (or vector) of values\n",
    "odds = [1,3,5,7]\n",
    "print('odds are:',odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first and last: 1 7\n"
     ]
    }
   ],
   "source": [
    "#you can access positions in a list\n",
    "#0 is first, 1 is second, etc\n",
    "#Negative positions count backward from the end\n",
    "print('first and last:',odds[0],odds[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for number in odds:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#you can change a single value in a list, as well\n",
    "odds[0] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print(odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lead\n"
     ]
    }
   ],
   "source": [
    "print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-087bb9e6a434>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mword\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'L'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#but even though you can access string positions, they're not lists\n",
    "word[0] = 'L'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "word = 'Lead'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lead\n"
     ]
    }
   ],
   "source": [
    "print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print(odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "odds[0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odds after adding a value: [1, 3, 5, 7, 11]\n"
     ]
    }
   ],
   "source": [
    "#add to the end of a list with append\n",
    "odds.append(11)\n",
    "print('odds after adding a value:',odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odds after removing the last element: [1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "#remove the item in a specific position with del\n",
    "del odds[-1]\n",
    "print('odds after removing the last element:',odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print(odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odds after reversing: [7, 5, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "#reverse changes the order (so position -1 becomes 0, -2 becomes 1 etc)\n",
    "odds.reverse()\n",
    "print('odds after reversing:',odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numbers after sorting: [1, 2, 3, 4, 7, 7, 9, 23]\n"
     ]
    }
   ],
   "source": [
    "#let's make an out of order list of numbers\n",
    "numbers = [2,7,9,3,1,4,23,7]\n",
    "#now use sort to put them in order\n",
    "numbers.sort()\n",
    "print(\"numbers after sorting:\",numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "primes: [1, 3, 5, 7, 2]\n",
      "odds [1, 3, 5, 7, 2]\n",
      "changing primes accidentally changed odds\n"
     ]
    }
   ],
   "source": [
    "#when you assign two variables as equal, they reference each other, not copy\n",
    "odds = [1,3,5,7]\n",
    "primes = odds\n",
    "primes.append(2)\n",
    "print('primes:',primes)\n",
    "print('odds',odds)\n",
    "print('changing primes accidentally changed odds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "primes: [1, 3, 5, 7, 2]\n",
      "odds [1, 3, 5, 7]\n",
      "success! We didnt add 2 to odds this time\n"
     ]
    }
   ],
   "source": [
    "odds = [1,3,5,7]\n",
    "#using list(odds) makes a copy instead of a reference\n",
    "primes = list(odds)\n",
    "primes.append(2)\n",
    "print('primes:',primes)\n",
    "print('odds',odds)\n",
    "print('success! We didnt add 2 to odds this time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not greater\n",
      "done!\n"
     ]
    }
   ],
   "source": [
    "#if expressions allow us to do other actions based on variable value \n",
    "num = 37\n",
    "#the format is \"if VAR TEST VALUE:\"\n",
    "if num > 100:\n",
    "    print('greater')\n",
    "#use else to tell Python what to do if an expression is false \n",
    "else:\n",
    "    print('not greater')\n",
    "print('done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before conditional...\n",
      "...after conditional\n"
     ]
    }
   ],
   "source": [
    "num = 53\n",
    "print(\"before conditional...\")\n",
    "#else isn't required; just nothing happens if the expression is false\n",
    "if num > 100:\n",
    "    print (num,'is greater 100')\n",
    "print('...after conditional')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3 is negative\n"
     ]
    }
   ],
   "source": [
    "num = -3\n",
    "#elif (else if) allows testing multiple possibilities in the same loop\n",
    "#if the first if is true, the elif and else are ignored\n",
    "#if the first if is false, the elif is tested next\n",
    "#else only runs if everything above is false\n",
    "if num > 0:\n",
    "    print(num,'is positive')\n",
    "elif num == 0:\n",
    "    print(num,'is zero')\n",
    "else:\n",
    "    print(num,'is negative')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one part is false\n"
     ]
    }
   ],
   "source": [
    "#you can use and to test if two things are both true\n",
    "if (1>0) and (-1 > 0):\n",
    "    print('both parts are true')\n",
    "else:\n",
    "    print('at least one part is false')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one test is true\n"
     ]
    }
   ],
   "source": [
    "#use or to test if at least one is true\n",
    "if (1 < 0) or (-1 < 0):\n",
    "    print('at least one test is true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#this is a comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one test is true\n"
     ]
    }
   ],
   "source": [
    "#this tests if one conditional is true\n",
    "if (1 < 0) or (-1 < 0):\n",
    "    print('at least one test is true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#packages add functionality to Python\n",
    "#import them with import\n",
    "#numpy is a package to add more numerical functions\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.666666666666667"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odds = [1,3,5,7,11,13]\n",
    "#calculate the average of the list\n",
    "#to use a procedure from a package use PACKAGE.PROCEDURE\n",
    "numpy.mean(odds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#what's the smallest odd?\n",
    "numpy.min(odds)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the largest\n",
    "numpy.max(odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congratulations! You made it! Now try Dataframes in Python!"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}