cwpk-31-reading-writing-files.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CWPK \\#31: Reading and Writing Files\n",
    "=======================================\n",
    "\n",
    "We Are Now Generating Info That Requires Persistence\n",
    "--------------------------\n",
    "\n",
    "<div style=\"float: left; width: 305px; margin-right: 10px;\">\n",
    "\n",
    "<img src=\"http://kbpedia.org/cwpk-files/cooking-with-kbpedia-305.png\" title=\"Cooking with KBpedia\" width=\"305\" />\n",
    "\n",
    "</div>\n",
    "\n",
    "We have been opening and using files for many installments in this [*Cooking with Python and KBpedia*](https://www.mkbergman.com/cooking-with-python-and-kbpedia/) series. However, in the past few installments, our methods are also beginning to generate serious results, some of thousands of lines. It is time for us to learn the basic commands for writing and reading files. We will also weave in a new [Python](https://en.wikipedia.org/wiki/Python_(programming_language)) import into our workspace, the [CSV](https://en.wikipedia.org/wiki/Comma-separated_values) module. It will be important for us as we begin to import the basic [N3](https://en.wikipedia.org/wiki/Notation3) and CSV files that underly [KBpedia](https://kbpedia.org/)'s build process.\n",
    "\n",
    "Another point we weave through today's installment is the usefulness of following Python's lead in composing the names of our files and methods in a hierarchical and logically named way. Such patterns mean we can more readily find and save the information we want to keep persistent. This patterning, along with some directory structure guidance we will address a few installments from now, help set up a logical way to manage and utilize the information assets in KBpedia (or your own domain extensions of it). Logical organization helps in a system designed for subset selections, semantic technology analysis, and machine learning, where the system itself is built from large, external files and we roundtrip with extractions from the current state of the graph.\n",
    "\n",
    "But reading and writing files is not a new subject for this series. Since early with our exposure to [owlready2](http://www.lesfleursdunormal.fr/static/informatique/owlready/index_en.html) and [Jupyter Notebook](https://en.wikipedia.org/wiki/Project_Jupyter) we have been loading and inspecting parts of KBpedia. You may recognize this call from [**CWPK #19**](https://www.mkbergman.com/2349/cwpk-19-exploring-the-api-to-owl/) regarding the smaller [KKO](https://kbpedia.org/docs/kko-upper-structure/) (Kbpedia Knowledge Ontology) <code>kko.owl</code>. We have not set up this notebook page sufficiently yet in this installment, so if you run this cell you will get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "onto.save(file = \"C:/1-PythonProjects/kbpedia/sandbox/kko-test.owl\", format = \"rdfxml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File Object and Methods\n",
    "To get started, let's first focus on the file object and the methods that may be applied to it in Python. A 'file object' has the following components:\n",
    "\n",
    "- A physical file address, which can be referenced by a variable name\n",
    "- A stated form of text encoding, which we standardize on as [UTF-8](https://en.wikipedia.org/wiki/UTF-8) in KBpedia\n",
    "- A method to be used when opening, whether read or write or append or others noted below.\n",
    "\n",
    "A 'file object' is given a variable name, which in this section let's simply call <code>f</code>. Python's <code>open()</code> and <code>close()</code> methods only apply to file objects. Thus, one can not simply 'open' a physical file address without first associating that physical file to a file object.\n",
    "\n",
    "Once a 'file object' is defined by assigning it a variable name, besides <code>f.open()</code> and <code>f.close()</code> certain other methods may be applied to the object:\n",
    "\n",
    "- <code>f.read(size)</code> - returns the text or binary document up to the 'size' indicated, which if omitted (<code>f.read()</code>) returns the entire file\n",
    "- <code>f.readline()</code> - returns a single line from the file with a new line character (<code>\\n</code>) appended to each line\n",
    "- <code>f.write(string)</code> - writes the contents that must be a string or a string variable, and returns the number of characters in that string\n",
    "- <code>f.tell()</code> - returns an integer giving the file object’s current position in the file\n",
    "- <code>f.seek(offset, where)</code> - re-sets the file object's location by an offset where the reference point is by convention either the beginning of the file (0), the current position (1) or the end of the file (2), with 0 the default\n",
    "- <code>f.truncate()</code> - see <code>help(file)</code> below and for many other more obscure ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The print() Function\n",
    "A quite different but major way to get output from a Python program is the <code>print()</code> built-in function. Because it is often the first statement we learn in a language ('Hello KBpedia!'), we tend to overlook the complexity and power of this function.\n",
    "\n",
    "A <code>print()</code> statement provides two kinds of output from Python. The first is the result from an evaluated expression (or code block), say the calculation of a formula. The second kind is for strings (that is, text and written numbers), which can be manipulated in many ways. Either output type may be directed to a file object. If all of the values passed to a print function are strings (or converted to such prior), then virtually all string <code>str</code> functions are available to manipulate the entire list of value information passed to the function.\n",
    "\n",
    "I encourage you to keep an eye out on the manifest ways the <code>print()</code> function is used in code examples you might inspect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open, Close and Reading Files\n",
    "It may not be obvious, but the underlying method to the Owlready2 <code>get.ontology(file)</code> method above is a wrapper around the standard Python file <code>open</code> method. \n",
    "\n",
    "<div class=\"boxPinkDotted\">\n",
    "<strong>Note:</strong> If you <code>open</code> a file in write (<code>'w'</code>) mode the file will be created if one does not already exist, but it will OVERWRITE one if it does exist!! Proceed with caution!\n",
    "</div>\n",
    "\n",
    "The <code>open</code> method works with different formats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-70fb0322830f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfile\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'r'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'utf8'\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[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'"
     ]
    }
   ],
   "source": [
    "file = open('C:/1-PythonProjects/kbpedia/sandbox/kko.owl','r', encoding='utf8') \n",
    "print(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if you repeat the command above, but remove the encoding argument and run again, you are likely to get an output format that indicates <code>encoding='cp1252'</code>. This kind of default encoding assignment can be DISASTROUS in working with KBpedia, where all input files and all output files must be in the UTF-8 encoding. It is best practice to specify encoding directly whenever opening or writing to files.\n",
    "\n",
    "Here is a slightly different format for opening a file now using a file object method of <code>read()</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'\n",
    "file=open(filename, 'r', encoding='utf8', errors='ignore')\n",
    "file.read()\n",
    "print(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, here is a third format using the 'with open' pattern of nested statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('C:/1-PythonProjects/kbpedia/sandbox/kko.owl') as file:\n",
    "  file.read()\n",
    "print(file)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oops! Did not work. Again, however, because we did not specify our encoding, we again get the default. We need to make the encoding explicit. Another thing to look out for is the separation of arguments by commas, which if missing, will throw another error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('C:/1-PythonProjects/kbpedia/sandbox/kko.owl', encoding='utf-8') as file:\n",
    "  file.read()\n",
    "print(file) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code>with open</code> statement above is the PREFERRED option because the 'with' format includes a graceful 'close' of the file should anything interrupt your work or the <code>with open</code> routine completes. Under the other options, a file can be left in an open state when a program terminates unexpectedly, possibly affecting the file integrity.\n",
    "\n",
    "In looking across the options above, let's make a couple of other points besides the need to specify the encoding. The first is that the file is opened by default in <code>'r'</code> read-only mode. You can see that mode specified in the <code>print</code> output even when not assigned directly. Other mode options include <code>'w'</code> when you wish to write or overwrite to the file, and <code>'a'</code> for append when you wish to add to the end of a file. Here is the complete suite of file mode options:\n",
    "\n",
    "- <code>'r'</code>   - opens a file for reading only\n",
    "- <code>'r+'</code>  - opens a file for both reading and writing\n",
    "- <code>'rb'</code>  - opens a file for reading only in binary format\n",
    "- <code>'rb+'</code> - opens a file for both reading and writing in binary format\n",
    "- <code>'w'</code>   - opens a file for writing only\n",
    "- <code>'a'</code>   - open for writing; the file is created if it does not exist\n",
    "- <code>'a+'</code>  - open for reading and writing; the file is created if it does not exist.\n",
    "\n",
    "Another thing to observe is that Python may accept more than one name alias for the encoding. Our examples above, for example, use both <code>'utf8'</code> or <code>'utf-8'</code> for the encoding argument.\n",
    "\n",
    "Also, as I admonished early in this **CWPK** series, try to always assign logical names to your physical file paths. As I noted earlier, there are tricky ways that Windows handles file names versus other operating systems and keeping (and then testing) proper file recognition in a separate assignment means you can develop and work with your code without worrying about file locations and paths. You may also do things programmatically to update or change the file referent for these logical names such that the actual file opened may be specified to a different physical location depending on context.\n",
    "\n",
    "A last thing to notice is that things like encoding or mode need not be specified as arguments in a given method command. When a default value is given at time of definition of the method (notably something to inspect for 'built-in' Python methods such as <code>file</code>), that argument can be left off what is actually written in code, with the default assignment being used. It is thus important to understand the commands you use, the options you may assign directly as an argument assignment, and the defaults they have. Whenever you get into trouble, first try to understand the full scope of the statements and their arguments available to you using the <code>dir</code> and <code>help</code> methods.\n",
    "\n",
    "Proper exiting of an application or writing to file generally requires you to <code>close()</code> the files you have opened. Again, if you open with the <code>with open</code> pattern, you should generally close gracefully. Nonetheless, here is the formal command, taking advantage of the fact we gave the physical file the logical name of 'file':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file.close()\n",
    "print(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output Options\n",
    "Well, apparently we have the KKO file object loaded, and we have seen the system recognize the file, but we still see nothing about what the file contains. Generally, of course, we need not inspect contents so long as our programs can access and use the data in them. But in some cases, like now when we are developing routines and we are validating steps, we want to make sure everything has opened properly for reading or to receive our outputs.\n",
    "\n",
    "At this point, we believe by running the cells above, that we have the <code>kko.owl</code> file in memory using the UTF-8 encoding. Let's test this premise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'\n",
    "file = open(filename, 'r', encoding='utf8')\n",
    "print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, while we specified the <code>'r'</code> reading option, that was strictly unnecessary since that is the default for the argument. But, if in doubt, there is no harm in specifying again.\n",
    "\n",
    "Here is another format for looping through a file line-by-line, now using an explicit <code>for</code> loop and using a logical <code>filename</code> for our physical file address:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'\n",
    "\n",
    "with open(filename, encoding='utf-8') as file:\n",
    "  lines = file.readlines()\n",
    "for line in lines:\n",
    "  print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hmmm, now that is interesting. The file appearance seems to skip every other line. That is because there is a whitespace character at the end of each line as we noted above under the file discussion. There is a string method for taking care of that, <code>.rstrip()</code> that we add to our routine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/kko.owl'\n",
    "\n",
    "with open(filename, encoding='utf8') as file:\n",
    "  lines = file.readlines()\n",
    "for line in lines:\n",
    "  print(line.rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The latter iteration option results in us being able to manipulate a string object in the line-by-line display, whcih means we may invoke many <code>str</code> options. Besides the example, two related methods are <code>.lstrip()</code> to remove leading whitespace and <code>.strip()</code> to remove both leading and trailing spaces.\n",
    "\n",
    "There are as many ways to iterate through the lines of a text file as there are ways to specify loops and iteration sequences in Python using <code>for</code>, <code>while</code> and other iteration forms. Also, there are many ways to conduct string manipulations including case changes, substitutions, counts, character manipulation, etc. To see some of these string (<code>str</code>) options, let's try the <code>dir()</code> command again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing Files\n",
    "Like the options for reading a file, there are a number of ways to write output to a file. \n",
    "\n",
    "In the 'write' examples below I have switched our variable file name from 'file' to 'my_file'. Though it is the case there are some Python keywords that you may not use (they will throw an error if used as variable names) and 'file' is NOT one of them (search on '[Python keywords](https://www.programiz.com/python-programming/keyword-list)' to find a listing of them). 'file' is also a not uncommon argument for some methods, including for the <code>print</code> statement. So, to prevent confusion, we'll switch to 'my_file'.\n",
    "\n",
    "Some programmers shorten such variable references to single letters, as we did so ourselves in the last installment (where the variable prefix went from <code>annot_</code> to <code>a_</code>). That style is OK for generic routines and ones perhaps using internal standards, but more descriptive variable names are helpful when your code is being used for learning or heuristic purposes, as is this case.\n",
    "\n",
    "OK, so let's look at some of these writing options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/write-test.txt'\n",
    "\n",
    "my_file = open(filename, 'w', encoding='utf8')\n",
    "print('Hello KBpedia!', file=my_file)\n",
    "\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note in this form we are continuing to specify the encoding and have changed the default <code>'r'</code> argument switch to <code>'w'</code> because we now want to be able to write to the file. (Note also we have changed the filename to a name something other than our existing files so that we do not inadvertently overwrite it.) We also need a <code>close()</code> statement to complete the write action and to properly close the file. After you run this cell, go to your standard directory where you first stored your local knowledge graphs and see the print statement in the new file.\n",
    "\n",
    "The next format uses our preferred form (though if the file is only being created and opened for immediate writing the above form is fine):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/write-test.txt'\n",
    "\n",
    "with open(filename, 'w', encoding='utf8') as my_file:\n",
    "  print('Hello KBpedia, again!', file=my_file)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have made your file declarations, you may also just write your statements as generated to the file. Notice for the third write statement below that we needed to mix our single and double quotes in order to include a possessive apostrophe in the statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/write-test.txt'\n",
    "my_file = open(filename, 'w', encoding='utf8')\n",
    "\n",
    "my_file.write('Slipping in a reference to KBpedia.')\n",
    "# More Python stuff\n",
    "my_file.write('And, then, another reference to KBpedia.')\n",
    "# More Python stuff\n",
    "my_file.write(\"Because I can't stop talking about this stuff!\")\n",
    "# More Python stuff\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, when we run this cell, we find the file has its text all on one line. Since we don't want that, we make modifications to the output statement, similar to what we might do for <code>print</code>. In this revision, we want to add a new line to the end of each string: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/write-test.txt'\n",
    "my_file = open(filename, 'w', encoding='utf8')\n",
    "\n",
    "my_file.write('Slipping in a reference to KBpedia.', '\\n')\n",
    "# More Python stuff\n",
    "my_file.write('And, then, another reference to KBpedia.', '\\n')\n",
    "# More Python stuff\n",
    "my_file.write(\"Because I can't stop talking about this stuff!\", \"\\n\")\n",
    "# More Python stuff\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grrr, I guess the <code>.write</code> method does not work the same as <code>print()</code>. But the type error indicates we can only pose a single argument to the statement, so we need to get rid of the second argument designated by the comma. Since we are working only with strings here, we can concatenate to get our statement down to a single argument (because what is first evaluated is between the parentheses, which results in a single value passed to the call):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'C:/1-PythonProjects/kbpedia/sandbox/write-test.txt'\n",
    "my_file = open(filename, 'w', encoding='utf8')\n",
    "\n",
    "my_file.write('Slipping in a reference to KBpedia.' + '\\n')\n",
    "# More Python stuff\n",
    "my_file.write('And, then, another reference to KBpedia.' + '\\n')\n",
    "# More Python stuff\n",
    "my_file.write(\"Because I can't stop talking about this stuff!\" + \"\\n\")\n",
    "# More Python stuff\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Better, that is more like it as our output file is formatted as we desire. \n",
    "\n",
    "You can also generate write statements that join together strings in various ways (this snippet does not work alone):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_file.write(' '.join(('Hello KBpedia!', str(var2), 'etc')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This brief overview points to either file object methods or the print function as two ways to get output out of your programs. Further, within each of these two major ways there are many styles and approaches that might be taken to get to your desired output goal.\n",
    "\n",
    "In the case of KBpedia where we use flat CSV files as our canonical exchange form, which are themselves by definition built from strings, we will tend to use <code>write()</code> function as our preferred way to prepare our strings for output. However, when reading the external files, we tend to use the file object read methods.\n",
    "\n",
    "Let me offer one final note on output considerations: Since we have only a relatively few generic processing steps for either extracting or building KBpedia, but ones that repeat across multiple modules or semantic object types, we will try to find ways to compose our file names from meaningful building block elements for consistency and understandability. We will start to see this in a fragmented way initially with our function and output definitions. When we get to the project-wide considerations, though, toward the concluding installments, we will be consolidating these fragments and building block considerations in a way that hopefully makes overall sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the CSV Module\n",
    "\n",
    "Though CSV files are easy to generate, manage, and inspect, and there is a formal standard with [RFC4180](https://www.ietf.org/rfc/rfc4180.txt), actual implementation is more like the Wild West. Delimiters other than commas or tabs may be used (semi-colons, etc.) to separate values. Specific purposes may add local specifications, such as the 'double pipe' ('||') convention we have adopted for multiple entries in a cell. Treatment of quoted strings, including what to quote and how to quote, may differ between applications. We have also discussed the importance of standard encodings, the failure of which to use may lead to disastrous file corruptions.\n",
    "\n",
    "CSV files in implementation have a standard layout of rows and columns, which is good, sometimes with headers and sometimes not. Though Microsoft Excel is a huge application for CSV files, Excel does not use UTF-8 as its standard and sometimes does other interesting things to its cell contents. It would be nice, for example, to have recognized templates that would enable us to move from one CSV environment to another. At minimum, we want to impose rigor and consistency to how we handle CSV files to prevent encoding mismatches or other discontinuities.\n",
    "\n",
    "To help overcome some of these challenges we are using the Python csv module. Let's first look and explore what functions this module has: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "dir(csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some of the attractive features of using the CSV module as our intermediary for data exchange. The CSV module:\n",
    "\n",
    "- Uses the same file object functions as standard Python, including an expanded <code>csv.reader</code> and <code>csv.writer</code>\n",
    "- Recognizes 'dialects', which are templates of processing specifications that can be defined or link to existing applications like Excel\n",
    "- Has a sniffer function to discover dialect regularities in new, wild files\n",
    "- Allows different quoting stringency levels to be set (all strings, multi-word strings, etc.)\n",
    "- Allows different delimiters to be set\n",
    "- Allows headers to be used or not\n",
    "- Recognizes field names for specific data columns\n",
    "- Enables Python dictionaries to mediate field names to master data.\n",
    "\n",
    "Though we have not yet come to our ingestion (build) steps, when we do we will have need for some fields to iterate multiple items to store in a single field name and to process it with a different delimiter ('||'). This and the master data dictionary aspects look promising.\n",
    "\n",
    "[Pandas](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) and [NumPy](https://numpy.org/doc/stable/contents.html) are additional CSV options with much more functionality should that be warranted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving from Jupyter Notebook\n",
    "\n",
    "To get output from your Jupyter Notebook, pick File &rarr; Download as to get full notebook outputs in nine different text-based formats and PDF. Of course, individual cells may also have their code blocks outputted via the Python functions discussed above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"Reading List and Additional-Documentation\">Reading List and Additional Documentation</h3>\n",
    "<p>There are many fine online series and books and many excellent printed ones with basic Python documentation. Citations at the bottom of many of these <strong>CWPK</strong> installments have links to some of them.</p>\n",
    "<p>If you are to follow this series closely I heartily recommend that you do so with a printed Python manual by your side that you can consult for specific commands or functions. I have spent some time looking, and have yet to find a single 'go-to' source for Python information. My most frequent sources are:</p>\n",
    "<div style=\"margin: 10px 40px; padding: 16px; background-color: #eee;\">Eric Matthes, <em>Python Crash Course, 2nd Edition</em>, 2019. No Starch Press, San Francisco, CA, 530 pp. ISBN-10: 1-59327-928-0<br /><br />Mark Lutz, <em>Learning Python, 3rd Edition</em>, 2008. O'Reilly Media, Inc., Sebastapol, CA, 706 pp. ISBN: 978-0-596-51398-6<br /><br />David Beasley and Brian K. Jones, <em>Python Cookbook: Recipes for Mastering Python 3, 3rd Edition</em>, 2013.  O'Reilly Media, Inc., Sebastapol, CA, 692 pp. ISBN: 978-1-449-34037-7<br /><br />Bill Lubanovic, <em>Introducing Python: Modern Computing in Simple Packages, 2nd Edition</em>, 2020. O'Reilly Media, Inc., Sebastapol, CA, 602 pp. ISBN: 978-1-492-05136-7</div>\n",
    "<p>Here are additional links useful to today's <strong>CWPK</strong> installment:</p>\n",
    "<ul>\n",
    "<li><a href=\"https://docs.python.org/3/tutorial/inputoutput.html\" target=\"_blank\" rel=\"noopener\">Input and output</a> from the official Python documentation</li>\n",
    "<li>RealPython's <a href=\"https://realpython.com/python-print/\" target=\"_blank\" rel=\"noopener\">Guide to the Python print() Function</a></li>\n",
    "<li>DataCamps's <a href=\"https://www.datacamp.com/community/tutorials/python-print-function\" target=\"_blank\" rel=\"noopener\">Python print() function</a>.</li>\n",
    "</ul>\n",
    "\n",
    " <div style=\"background-color:#efefff; border:1px dotted #ceceff; vertical-align:middle; margin:15px 60px; padding:8px;\"> \n",
    "  <span style=\"font-weight: bold;\">NOTE:</span> This article is part of the <a href=\"https://www.mkbergman.com/cooking-with-python-and-kbpedia/\" style=\"font-style: italic;\">Cooking with Python and KBpedia</a> series. See the <a href=\"https://www.mkbergman.com/cooking-with-python-and-kbpedia/\"><strong>CWPK</strong> listing</a> for other articles in the series. <a href=\"http://kbpedia.org/\">KBpedia</a> has its own Web site.\n",
    "  </div>\n",
    "\n",
    "<div style=\"background-color:#ebf8e2; border:1px dotted #71c837; vertical-align:middle; margin:15px 60px; padding:8px;\"> \n",
    "\n",
    "<span style=\"font-weight: bold;\">NOTE:</span> This <strong>CWPK \n",
    "installment</strong> is available both as an online interactive\n",
    "file <a href=\"https://mybinder.org/v2/gh/Cognonto/CWPK/master\" ><img src=\"https://mybinder.org/badge_logo.svg\" style=\"display:inline-block; vertical-align: middle;\" /></a> or as a <a href=\"https://github.com/Cognonto/CWPK\" title=\"CWPK notebook\" alt=\"CWPK notebook\">direct download</a> to use locally. Make sure and pick the correct installment number. For the online interactive option, pick the <code>*.ipynb</code> file. It may take a bit of time for the interactive option to load.</div>\n",
    "\n",
    "<div style=\"background-color:#feeedc; border:1px dotted #f7941d; vertical-align:middle; margin:15px 60px; padding:8px;\"> \n",
    "<div style=\"float: left; margin-right: 5px;\"><img src=\"http://kbpedia.org/cwpk-files/warning.png\" title=\"Caution!\" width=\"32\" /></div>I am at best an amateur with Python. There are likely more efficient methods for coding these steps than what I provide. I encourage you to experiment -- which is part of the fun of Python -- and to <a href=\"mailto:mike@mkbergman.com\">notify me</a> should you make improvements.    \n",
    "\n",
    "</div>"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}