006_Read_and_Write_Text_Files.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://www.hydroffice.org/epom/\"><img src=\"images/000_000_epom_logo.png\" alt=\"ePOM\" title=\"Open ePOM home page\" align=\"center\" width=\"12%\" alt=\"Python logo\\\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://piazza.com/class/js5dnu0q39n6qe\"><img src=\"images/help.png\" alt=\"ePOM\" title=\"Ask questions on Piazza.com\" align=\"right\" width=\"10%\" alt=\"Piazza.com\\\"></a>\n",
    "# Read and Write Text Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have learned about lists and how to [write your own functions](005_Write_Your_Own_Functions.ipynb) with [loops](004_Loops.ipynb) and [conditional statements](003_Conditional_Execution.ipynb). This allows you to write programs performing a variety of tasks. \n",
    "\n",
    "However, a convenient mechanism to access data that you want to analyze is currently missing. In this notebook, we will explore the use of [files](https://en.wikipedia.org/wiki/Computer_file) since they are a common way to access stored data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "A **file** provides a mechanism for **permanently storing information**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two main types of files: text files and binary files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "A **text file** is a file that only contains plain or marked-up text.<br>A **binary file** is any other type of computer file that does not fit the previous definition of a text file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can often recognize a text file by looking at the [file extension](https://en.wikipedia.org/wiki/Filename_extension). Commonly used text files extensions are: `.txt`, `.asc`, `.xyz`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "A very simple test to evaluate whether a given file is a text file is to open it in a text editor. If you can recognize the visualized content of an opened file as text, then the file is likely a text file. *(Be warned that opening a file in this way can take a long time depending on the size of the file.)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first introduce some file management capabilities of the `os.path` [Python module](https://docs.python.org/3.6/tutorial/modules.html#modules), then we will use the functions that Python provides for [reading and writing the content of a text file](https://docs.python.org/3.6/tutorial/inputoutput.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "In Python, a **module** is a file containing code (e.g., definitions and statements). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The module name is given by the file name without the [file extension](https://en.wikipedia.org/wiki/Filename_extension). For example, a file `example.py` identifies the module `example`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "Python has native functions to read and write text files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `os.path` module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here you will explore the `os.path` module to retrieve data files that are stored on the server's hard disk."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "Several functions in the `os.path` module are **portable**. This means that they can be used [across different operating systems](https://en.wikipedia.org/wiki/Cross-platform_software). For example, you can use `os.path` functionality in code that runs on [Linux Ubuntu](https://en.wikipedia.org/wiki/Ubuntu) and [Microsoft Windows 10](https://en.wikipedia.org/wiki/Windows_10)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "To have access to the `os.path` module functionality, it first must be made available using the **import** statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, we write a `get_current_folder()` function that returns the path of the folder where *this* notebook is located."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve this task, we will use two of the `os.path` functions and variables:\n",
    "\n",
    "- `curdir`: The string used by the [operating system](https://en.wikipedia.org/wiki/Operating_system) to refer to the current directory.\n",
    "- `abspath()`: A function that returns the [absolute path](https://en.wikipedia.org/wiki/Path_(computing)#Absolute_and_relative_paths)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "An [**absolute path**](https://en.wikipedia.org/wiki/Path_(computing)#Absolute_and_relative_paths) points to the same location in a file system, regardless of the current working directory. In contrast, a [**relative path**](https://en.wikipedia.org/wiki/Path_(computing)#Absolute_and_relative_paths) starts from a given working directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os.path\n",
    "\n",
    "def get_current_folder():\n",
    "    cur_folder = os.path.abspath(os.path.curdir) # get a string containing the absolute path to the current directory\n",
    "    return cur_folder \n",
    "\n",
    "print(\"The current folder is: \" + get_current_folder())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The data that we will use for our following examples are contained in the `data` sub-folder (see image below): \n",
    "\n",
    "![Function Terminology](images/007_100_data_folder.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be able to access the `data` sub-folder, we extend the previous code using `os.path.join()` and `os.path.exists()` functions to:\n",
    "\n",
    "- Create the absolute path to the `data` sub-folder.\n",
    "- Check whether the resulting path actually exists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case that the `data` sub-folder does not exist, we raise an error using the [`raise`](https://docs.python.org/3.6/tutorial/errors.html#raising-exceptions) keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_folder():\n",
    "    cur_folder = os.path.abspath(os.path.curdir) # get a string containing the absolute path to the current directory\n",
    "    data_folder = os.path.join(cur_folder, \"data\") # augment the cur_folder path with the data directory\n",
    "    if os.path.exists(data_folder): \n",
    "        return data_folder\n",
    "    else:  # raise a meaningful error if the data folder does not exist\n",
    "        raise RuntimeError(\"Unable to locate the data folder: \" + data_folder)\n",
    "\n",
    "print(\"The data folder is: \" + get_data_folder())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "We did not import the `os.path` module since it was previously imported in this notebook. Re-importing a module does not break your code, but makes it more verbose. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you decide to [clear the results of this notebook](000_Welcome_on_Board.ipynb#How-to-Clear-the-Results-of-a-Notebook?), you will need to re-execute the code cell with the `import` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "If you want to know more about error handing and exceptions, read [Errors and Exceptions](https://docs.python.org/3.6/tutorial/errors.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now retrieve all the paths to the files in the `data` folder. Specifically, we will create a function `get_data_paths()` that returns a list containing all the files in that folder, using the `os.listdir()` function from the `os` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "def get_data_paths():\n",
    "    data_paths = list()  # create an empty list to be populated and returned\n",
    "    data_folder = get_data_folder() # call the function you created to return the data directory path\n",
    "    data_filenames = os.listdir(data_folder) # call listdir() to get all the filenames in your data directory\n",
    "\n",
    "    # Combine each data file name in the data_filenames list with the full path\n",
    "    for data_filename in data_filenames:\n",
    "        data_path = os.path.join(data_folder, data_filename) # join the absolute path with the file name\n",
    "        data_paths.append(data_path)  # add the data_path for this file to a list of data paths\n",
    "    \n",
    "    data_paths.sort()  # sort the paths in alphabetical order\n",
    "\n",
    "    return data_paths  # return the list of all the file paths\n",
    "\n",
    "\n",
    "retrieved_paths = get_data_paths()\n",
    "print(\"The data paths are: \" + str(retrieved_paths))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, we wrote a function in which a list: `data_paths` is created, populated and returned. The function:\n",
    "\n",
    "- Creates an empty list.\n",
    "- Calls the previously created function `get_data_folder()`.\n",
    "- Uses Python functions from the `os.path` module: e.g., `listdir()`, `join()`.\n",
    "- Executes a `for` loop to populate the `data_paths` list.\n",
    "- Returns the populated list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "You do not need to remember all the names of the available Python functions, but you need to learn how to search for them. The [official Python documentation](https://docs.python.org/3.6/index.html) is a good place to start. You can also get a list of the functions in the `os.path` module by entering `dir(os.path)` in a code cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the [Lists of Variables notebook](002_Lists_of_Variables.ipynb), you know how to access an item in a list by its index. \n",
    "\n",
    "In this particular case, to access the file name `sal.txt`, we will use `1` as index since it is the **second** element in the `retrieved_paths` list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sal_path = retrieved_paths[1]\n",
    "print(\"The file path with index 1 is: \" + sal_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "**CAUTION**: The above solution works **specifically** with the current directory content. For instance, changing the directory content may alter the index of the salinity file in the list, thus breaking your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section, you will learn how to open and read the content of `sal_path`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read a Text File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "The Python `open()` function takes the name of the file (as a parameter) and returns a [file object](https://docs.python.org/3.6/glossary.html#term-file-object). <br> The `close()` function closes the open file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This file object can be used to read the sequence of characters contained in a text file in a few different ways:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The `readline()` method reads a single line from the text file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sal_file = open(sal_path)\n",
    "\n",
    "sal_line = sal_file.readline()\n",
    "print(sal_line)\n",
    "\n",
    "sal_file.close()  # the close() method closes the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The `read()` method reads the entire text file.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sal_file = open(sal_path)\n",
    "\n",
    "sal_content = sal_file.read() # assigns the contents of the file to a string variable\n",
    "print(sal_content)\n",
    "\n",
    "sal_file.close()  # the close() method closes the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The execution of the above code will print the 20 salinity values in the text file. Although they look like numbers, they are **actually** a single `str` consisting of a 100 characters!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(sal_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(sal_content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may ask why there are 100 characters instead of 80? Each of the 20 rows has 4 visible characters (e.g., `30.8`), but there is also the invisible [newline character](https://en.wikipedia.org/wiki/Newline) (i.e., `\\n`) that text editors treat as a break between two lines. Thus, `(4+1) * 20 = 100` characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/key.png\">\n",
    "\n",
    "The **newline character** is used to end a line of text and to start a new one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above, the `sal_content` variable holds the content of the file as a single sequence of characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now write a function that not only reads the sequence of characters, but also splits them in multiple lines based on the **newline character** (using the `str` method named `splitlines()`). Finally, we convert the results to corresponding `float` values and append these to `sal_list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_salinity_values(input_path):\n",
    "    sal_list = list()\n",
    "    \n",
    "    sal_file = open(input_path)\n",
    "    sal_content = sal_file.read()\n",
    "    sal_file.close()\n",
    "    \n",
    "    sal_lines = sal_content.splitlines()  # split the string sal_content by the newline characters in this file\n",
    "    for sal_line in sal_lines:\n",
    "        sal_list.append(float(sal_line))  # convert the string in each line to float, then append to the list\n",
    "    \n",
    "    return sal_list\n",
    "\n",
    "sal_path = retrieved_paths[1]\n",
    "sal_values = read_salinity_values(input_path=sal_path) # does the same as sal_values = read_salinity_values(sal_path)\n",
    "print(sal_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "In Python, there are more efficient methods to read a text file. We adopted an approach here that is simple to understand for a first-time learner."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/test.png\">\n",
    "\n",
    "Write code similar to the previous **Code** cell, but that reads the temperature values in the `temp.txt` file. *Hint: the path is at index `2` in the `retrieved_paths` list.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "def read_temperature_values(input_path):\n",
    "    temp_list = list()\n",
    "    \n",
    "    temp_file = open(input_path)\n",
    "    temp_content = temp_file.read()\n",
    "    temp_file.close()\n",
    "    \n",
    "    temp_lines = temp_content.splitlines()\n",
    "    for temp_line in temp_lines:\n",
    "        temp_list.append(float(temp_line))\n",
    "    \n",
    "    return temp_list\n",
    "\n",
    "temp_path = retrieved_paths[2]\n",
    "temp_values = read_temperature_values(input_path=temp_path)\n",
    "print(temp_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write a Text File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to write a text file, you need to decide where to store it. For this collection of notebooks, we will use the `output` directory that can be retrieved running the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_output_folder():\n",
    "    cur_folder = os.path.abspath(os.path.curdir)  # the absolute path to the current directory\n",
    "    output_folder = os.path.join(cur_folder, \"output\")  # the absolute path to the output folder (may or may not exist)\n",
    "    if os.path.exists(output_folder):\n",
    "        return output_folder\n",
    "    else:  # raise a meaningful error if the output folder does not exist\n",
    "        raise RuntimeError(\"Unable to locate the output folder: \" + output_folder)\n",
    "\n",
    "output_folder = get_output_folder()\n",
    "print(\"The output folder is: \" + output_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can then use the `join()` function to assign an output file name: e.g., `depths.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "depths_path = os.path.join(output_folder, \"depths.txt\")\n",
    "print(\"The output file path is: \" + depths_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code below, the `write_list_to_disk` function has the arguments:\n",
    "\n",
    "* `output_path` as the location where the output file is to be written. \n",
    "* `input_list` as a list containing the data to be written to the output file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `write_list_to_disk` function below opens a file in the `w` mode (`w` is for *write*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "You may learn about other modes for opening a file from the official [Python documentation](https://docs.python.org/3.6/library/functions.html?#open)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_list_to_disk(output_path, input_list):\n",
    "    \n",
    "    output_file = open(output_path, mode=\"w\")  # mode=\"w\" to open the file in writing mode\n",
    "    \n",
    "    for value in input_list:\n",
    "        line_content = str(value) + \"\\n\"  # the \"\\n\" is the newline character\n",
    "        output_file.write(line_content)\n",
    "        \n",
    "    output_file.close()\n",
    "    \n",
    "depths_path = os.path.join(output_folder, \"depths.txt\")\n",
    "depths_list = [1943.2, 1232.1, 132.2, 2.42, 123.5, 1093.2]\n",
    "write_list_to_disk(output_path=depths_path, input_list=depths_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/test.png\">\n",
    "\n",
    "Write code that prints the contents of the \"depths.txt\" file written in the above *Code* cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "depths_path = os.path.join(output_folder, \"depths.txt\")  # the file path is the same as before\n",
    "\n",
    "depths_file = open(depths_path)  # we don't need to add the `mode` parameter since the default value is 'r' for read\n",
    "depths_content = depths_file.read()  # we retrieve the full content of the file as a single, multi-line string\n",
    "depths_file.close()  # we close the file since we have already read its content\n",
    "\n",
    "print(depths_content)  # we print the string content of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read and Write Binary Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px;\" src=\"images/info.png\">\n",
    "\n",
    "Although Python also provides access to the content of a [binary file](https://en.wikipedia.org/wiki/Binary_file), you will need to know the format specifications on how the content is organized to properly interpret its content. This kind of task is outside the scope of this collection of notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"6%\" style=\"padding-right:10px; padding-top:10px;\" src=\"images/refs.png\">\n",
    "\n",
    "## Useful References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [The official Python 3.6 documentation](https://docs.python.org/3.6/index.html)\n",
    "  * [The os module](https://docs.python.org/3.6/library/os.html)\n",
    "  * [Input and Output](https://docs.python.org/3.6/tutorial/inputoutput.html)\n",
    "* [Cross-platform software](https://en.wikipedia.org/wiki/Cross-platform_software)\n",
    "* [Computer file](https://en.wikipedia.org/wiki/Computer_file)\n",
    "  * [Text file](https://en.wikipedia.org/wiki/Text_file)\n",
    "  * [Binary file](https://en.wikipedia.org/wiki/Binary_file)\n",
    "  * [Filename extension](https://en.wikipedia.org/wiki/Filename_extension)\n",
    "* [Absolute and relative paths](https://en.wikipedia.org/wiki/Path_(computing)#Absolute_and_relative_paths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"left\" width=\"5%\" style=\"padding-right:10px;\" src=\"images/email.png\">\n",
    "\n",
    "*For issues or suggestions related to this notebook, write to: epom@ccom.unh.edu*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "[< Write Your Own Functions](005_Write_Your_Own_Functions.ipynb) | [Contents](index.ipynb) | [Dictionaries and Metadata >](007_Dictionaries_and_Metadata.ipynb)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}