Python_ES_L4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Python for Earth Scientists: Lesson 4\n",
    "# Run this cell in order to create the variables below. These variables will be used in the\n",
    "# lesson. If for any reason you change one of these variables by mistake, you can re-run\n",
    "# this cell in order to reset the variables. We will refer to this cell as the \"first variables\n",
    "# cell\". This cell may look familiar from last lesson.\n",
    "\n",
    "from IPython.display import HTML # Ignore this library\n",
    "from IPython.display import display # Ignore this library\n",
    "\n",
    "from tkinter import filedialog as fd # File dialog library. This can be used to select folders \n",
    "import numpy as np # Import numpy as np\n",
    "import csv # Import csv library\n",
    "\n",
    "# President Lists\n",
    "first_NAME = ['George', 'Thomas','Abraham','Franklin','Ronald','Barack','Donald'] # Character List \n",
    "last_NAME = ['Washington', 'Jefferson','Lincoln','Roosevelt','Reagan','Obama','Trump'] # Character List \n",
    "IQ = [100,150,120,115,90,130,110] # Numerical list\n",
    "\n",
    "# Create dictionary for Presidents\n",
    "Presidents = {'First Name': first_NAME,'Last Name': last_NAME,'Intelligence': IQ} \n",
    "\n",
    "# Monarch Lists\n",
    "monarch_NAME = ['Edward I','Henry VIII','Elizabeth I','George III','Victoria']\n",
    "reign_START = [1272,1509,1558,1760,1837]\n",
    "reign_END = [1307,1547,1603,1820,1901]\n",
    "monikER = ['Longshanks','Bad Husband','Oriana','the mad King','Widow of Winsor']\n",
    "\n",
    "# Create dictionary for Monarchs. \n",
    "Monarchs = {} # Create an empty dictionary. \n",
    "Monarchs['Name'] = monarch_NAME # \n",
    "Monarchs['Start'] = reign_START\n",
    "Monarchs['End'] = reign_END\n",
    "Monarchs['Nickname'] = monikER\n",
    "\n",
    "# NOTE: Because python is flexible, we create our two dictionaries using differen methods.\n",
    "# However, are created in different ways, but the result is the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Review:\n",
    "\n",
    "# 1. For-loop indexing with enumerate\n",
    "# 2. with statements\n",
    "# 3. conditional statements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Review:\n",
    "\n",
    "# 4. creating csv files from dictionaries: user-defined functions\n",
    "# 4a. Create function\n",
    "\n",
    "def Dict2CSV(file_name,GENERIC_DICT,**kwargs):\n",
    "    \"\"\"This function will take a dictionary (GENERIC_DICT) and write it into a csv file called (file_name).\n",
    "    \"GENERIC_DICT\" is any dictionary comprised of equally sized lists. file_name should contain not only the \n",
    "    desired file name, but also the pathway for accessing it. Set DELIMITER equal to desired delimiter (e.g. ',','\\t, etc.)\"\"\"\n",
    "    seP = kwargs['DELIMITER'] # Keyword argument. Set this equal to the desired delimiter\n",
    "    with open(file_name,'w') as FID: # Creates a brand new csv file and file identifier\n",
    "        CSV_WRITE = csv.writer(FID, delimiter=seP,quotechar='|') # Creates writer object\n",
    "        CSV_WRITE.writerow(GENERIC_DICT.keys()) # writes GENERIC_DICT keys as the first line of \"data\"\n",
    "        # Now we need to count the elements in each of our lists. They should be the same for all keys\n",
    "        # so we only need to do this once.\n",
    "        keY_LIST = list(GENERIC_DICT.keys()) # Make a list containing all GENERIC_DICT keys\n",
    "        # We don't know how many keys will be in this list because it may be different for \n",
    "        # each dictionary. But we know that all dictionaries contain AT LEAST one key!\n",
    "        first_KEY = keY_LIST[0] # Find the name of GENERIC_DICT's first key\n",
    "        first_LST = GENERIC_DICT[first_KEY] # Find the length of list inside GENERIC_DICT's first key\n",
    "        numELEMENT = len(first_LST) # Find the number of elements inside GENERIC_DICT's first key\n",
    "        for i in range(numELEMENT): \n",
    "            # Using the function \"range\", this for-loop cycles through an array of integers. These\n",
    "            # integers increase in value from 0 to numELEMENT-1 and correspond to the indices of\n",
    "            # lists contained in GENERIC_DICT keys\n",
    "            roW = [] # Create an empty list called \"roW\"\n",
    "            for p in GENERIC_DICT.keys():\n",
    "                # This is a nested for-loop that runs inside of the big for loop by cycling through\n",
    "                # generic dictionary keys. \n",
    "                eLMT = GENERIC_DICT[p][i] # Variable for each dictionary key element. \n",
    "                roW.append(eLMT) # Add eLMT to roW (initially empty)\n",
    "            CSV_WRITE.writerow(roW) # writes roW into the csv file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Review:\n",
    "\n",
    "# 4. creating csv files from dictionaries: user-defined functions\n",
    "# 4b. Writing code\n",
    "\n",
    "diRECTORY = fd.askdirectory() + '/' # Select directory using dialog box\n",
    "print(diRECTORY) # Print selected directory\n",
    "Dict2CSV(diRECTORY+'UnitedStates_Presidents.txt',Presidents,DELIMITER='\\t') # Text file w tabs\n",
    "Dict2CSV(diRECTORY+'UnitedKingdom_Monarchs.csv',Monarchs,DELIMITER=',') # CSV file w commas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1. By now, hopefully you all are well acquainted with our friend the for-loop. Now let's \n",
    "# examine while loops. While loops run continously until the user specifies otherwise. They \n",
    "# are useful for performing iterations when the number of repetitions needed is unknown at the \n",
    "# onset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1a. Run your first while loop!\n",
    "\n",
    "keY = 0 # Create a variable that will increase inside while loop\n",
    "while keY < 10: # Run this while loop as long as keY is LESS THAN 10\n",
    "    keY = keY + 1 # Increase keY by 1 inside the while loop\n",
    "    print(keY) # Print keY each time the while loop runs\n",
    "print('While loop successful! Key = ' + str(keY)) # Print a line after the while loop ends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1b. Run the same while loop, but in an alternative (better) format!\n",
    "\n",
    "keY = 0 # Create a variable that will increase inside while loop\n",
    "while 1: # While loop will run perpetually until we tell it otherwise\n",
    "    keY+=1 # Increase keY by 1 inside the while loop\n",
    "    print(keY) # Print keY each time the while loop runs\n",
    "    if keY >= 10: # If keY is greater than or equal to 10\n",
    "        break # Break the while loop\n",
    "print('While loop successful! Key = ' + str(keY)) # Print a line after the while loop ends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1c. Review: For loops can be used to find objects in lists.\n",
    "\n",
    "namES = monarch_NAME + first_NAME # Combine two lists\n",
    "for n in namES:\n",
    "    # Cycle through the names with a for-loop\n",
    "    if n == 'George': # If n is equal to \"George\"\n",
    "        break # Break the for-loop\n",
    "print('Name = ',n) # Print n to make sure that it's indeed \"George\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1d. While loops combined with indexing can ALSO be used to find objects in lists\n",
    "\n",
    "namES = monarch_NAME + first_NAME # Combine two lists\n",
    "keY = 0 # Create a variable that will increase inside while loop (we can use to index)\n",
    "while 1: # While loop will run perpetually until we tell it otherwise\n",
    "    THE_BOSS = namES[keY] # Create variable by indexing namES (unnecessary step)\n",
    "    if THE_BOSS == 'George': # If THE_BOSS is equal to \"George\"\n",
    "        break # Break the for-loop\n",
    "    keY += 1 # Increase keY by 1\n",
    "print('Name = ',THE_BOSS) # Print n to make sure that it's indeed \"George\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1e. While loops combined with indexing can ALSO be used to find objects in lists\n",
    "\n",
    "namES = monarch_NAME + first_NAME # Combine two lists\n",
    "keY = 0 # Create a variable that will increase inside while loop (we can use to index)\n",
    "while 1: # While loop will run perpetually until we tell it otherwise\n",
    "    THE_BOSS = namES[keY] # Create variable by indexing namES (unnecessary step)\n",
    "    if 'orge' in THE_BOSS: # If THE_BOSS is equal to \"George\"\n",
    "        break # Break the for-loop\n",
    "    keY += 1 # Increase keY by 1\n",
    "print('Name = ',THE_BOSS) # Print n to make sure that it's indeed \"George\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 1f. Why did 1d and 1e produce diferent answers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Answer to 1f: Run this cell to cover the answer\n",
    "\n",
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To see the answer, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "###############################################################################################\n",
    "\n",
    "# The conditional statement \"if variable == string\" categorizes variables if they are EQUAL to \n",
    "# a string. The conditional statement \"if string in variable\" categorizes variables if a string\n",
    "# is present in variable. Variable does not have to be equal to the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 2. In lesson 4 we learned how to write dictionaries into ascii files. Now we will focus on \n",
    "# reading ascii files into dictionaries.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#2a Run this code. Select the file titled \"demo.txt\". Read each line of code in a for-loop\n",
    "\n",
    "demo_FILE = fd.askopenfilename() # Select a file\n",
    "with open(demo_FILE) as FID: # Open the file\n",
    "    for i,linE in enumerate(FID):\n",
    "        # Use a for-loop to read each line of the ascii file.\n",
    "        print('line ',i+1,':',linE) # print the line of the ascii file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#2b Run this code. Select the file titled \"demo.txt\". Read each line of code in a for-loop\n",
    "\n",
    "#demo_FILE = fd.askopenfilename() # Select a file\n",
    "keY = 0 # Key to index line\n",
    "with open(demo_FILE) as FID: # Open the file\n",
    "    while 1: # While loop that goes through the ascii file.\n",
    "        linE = FID.readline() # Grab line of data\n",
    "        if linE == '': # If linE is empty...\n",
    "            # We have likely reached the end of the file.\n",
    "            break  # Break the while loop\n",
    "        else: # If linE is NOT empty ...     \n",
    "            # We have NOT reached the end of the file\n",
    "            print('line ',keY+1,':',linE) # Print line of data\n",
    "            keY += 1 # increase keY by 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3. Create a user-define function to read meteorological data into dictionary\n",
    "\n",
    "def weather_UNDERGROUND_READER(file_NAME,**kwargs):\n",
    "    \"\"\"weather_UNDERGROUND_READER reads a meteorogical ascii file and outputs it as a dictionary.\n",
    "    DELIMITER keyword argument must be set equal to a specific delimiter (comma, tab, etc.)\"\"\"\n",
    "    seP = kwargs['DELIMITER'] # Call DELIMITER from kwargs. Set it equal to a variable\n",
    "    with open(file_NAME) as FID: # Open file_NAME\n",
    "        FID.readline() # Skip over the FIRST line of file by not assigning it to a variable\n",
    "        titlE = FID.readline() # Read the second line of file, which is the title file.\n",
    "        titlE = titlE.strip().split(',') # Convert titlE from string to list\n",
    "#        FID.readline() # Skip over the THIRD line of file by not assigning it to a variable\n",
    "        METEOLOGICAL_DATA = {} # Create dictionary for meteorological data\n",
    "        for t in titlE:\n",
    "            # forloop builds METEOLOGICAL_DATA by setting keys equal to empty lists\n",
    "            METEOLOGICAL_DATA[t] = [] # Create empty list for each title header\n",
    "        for linE in FID:\n",
    "            # For-loop goes through each ascii file line by line\n",
    "            linE = linE.strip().split(',') # Convert linE from string to list\n",
    "            for i,t in enumerate(titlE): \n",
    "                # Nested for-loop grabs title headers, and uses them to index ascii values and\n",
    "                # append them to the correct list (inside a key)\n",
    "                METEOLOGICAL_DATA[t].append(linE[i]) # Append ascii value to a list. Use title header to find list\n",
    "            FID.readline() # Skip over EVERY OTHER LINE in ascii file because they are blank\n",
    "    return(METEOLOGICAL_DATA)\n",
    "                \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3a. Test your function with \"demo1.txt\". Does it work?\n",
    "Weather_DICT = weather_UNDERGROUND_READER(demo_FILE,DELIMITER=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3b. Now test your function with \"demo2.txt\". Does it work?\n",
    "\n",
    "demo_FILE2 = fd.askopenfilename() # Select a demo2.txt using dialog box\n",
    "Weather_DICT2 = weather_UNDERGROUND_READER(demo_FILE2,DELIMITER=',') # read file to dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 4. Consult with your group members to improve weather_UNDERGROUND_READER. In the cell \n",
    "# below (4a), update your user-defined function so that it is more versatile with ascii files\n",
    "# that have different header lines between the top of the data sheet and the column headers. \n",
    "# When you are satisfied with your changes, run cell 4a. Then test your code by running cell 4b.\n",
    "# A solution to this problem set is found in cell 4c.\n",
    "\n",
    "# Hint: Try smaller simpler changes before getting complex. Less is more!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 4a. Improve \"weather_UNDERGROUND_READER\" in the space below. \n",
    "# Call this new function \"weather_UNDERGROUND_READER_upadated\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 4b. Test the user-defined function that you created/modified in\n",
    "Weather_DICT_updated = weather_UNDERGROUND_READER_upadated(demo_FILE,DELIMITER=',')\n",
    "Weather_DICT2_updated = weather_UNDERGROUND_READER_upadated(demo_FILE2,DELIMITER=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 4c. Answer is shown below. Run this cell to comment the answer. No cheating!\n",
    "\n",
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To see the answer, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "###############################################################################################\n",
    "\n",
    "\n",
    "# By commenting out the first line of code under the with-statement and adding a simple \n",
    "# while-loop and if-statement, we can improve our function so that it works for a header of\n",
    "# any length!\n",
    "\n",
    "def weather_UNDERGROUND_READER_upadated(file_NAME,**kwargs):\n",
    "    \"\"\"weather_UNDERGROUND_READER reads a meteorogical ascii file and outputs it as a dictionary.\n",
    "    DELIMITER keyword argument must be set equal to a specific delimiter (comma, tab, etc.)\"\"\"\n",
    "    seP = kwargs['DELIMITER'] # Call DELIMITER from kwargs. Set it equal to a variable\n",
    "    with open(file_NAME) as FID: # Open file_NAME\n",
    "#        FID.readline() # Skip over the FIRST line of file by not assigning it to a variable\n",
    "        while 1:\n",
    "            titlE = FID.readline() # Read the second line of file, which is the title file.\n",
    "            if 'Time,Temp' in titlE:\n",
    "                break\n",
    "        titlE = titlE.strip().split(',') # Convert titlE from string to list\n",
    "#        FID.readline() # Skip over the THIRD line of file by not assigning it to a variable\n",
    "        METEOLOGICAL_DATA = {} # Create dictionary for meteorological data\n",
    "        for t in titlE:\n",
    "            # forloop builds METEOLOGICAL_DATA by setting keys equal to empty lists\n",
    "            METEOLOGICAL_DATA[t] = [] # Create empty list for each title header\n",
    "        for linE in FID:\n",
    "            # For-loop goes through each ascii file line by line\n",
    "            linE = linE.strip().split(',') # Convert linE from string to list\n",
    "            for i,t in enumerate(titlE):\n",
    "                # Nested for-loop grabs title headers, and uses them to index ascii values and\n",
    "                # append them to the correct list (inside a key)\n",
    "                METEOLOGICAL_DATA[t].append(linE[i]) # Append ascii value to a list. Use title header to find list\n",
    "            FID.readline() # Skip over EVERY OTHER LINE in ascii file because they are blank\n",
    "    return(METEOLOGICAL_DATA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}