6_Print formatting_File input and output.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print formatting; file input and output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing\n",
    "\n",
    "Print formatting in Python builds on the *for*-loops and simple file input introduced in notebook 4 (you may want to review these). For printing, we usually use the Python **print()** command\n",
    "\n",
    "    print (<exp1>, ..., <expn>)\n",
    "    \n",
    "which prints expressions on one line, adding a space in between. It then outputs a *newline* (or linebreak) unless you use the argument\n",
    "\n",
    "    end = \"\"\n",
    "\n",
    "You can add any character between the quotes (white space, comma, dot, alphanumeric characters etc). By default, *print* prints to standard output stream which has the name\n",
    "**sys.stdout**. You can write to another stream with\n",
    "\n",
    "    file = <variable-name>\n",
    "\n",
    "Such as\n",
    "\n",
    "    out = open('outputfile.txt','w')\n",
    "    print ('some output string', file = out)\n",
    "    \n",
    "You need *string interpolation* to produce nicely formatted output, such as tidily aligned lists of numbers. This is carried out using the \"%\" operator. This has multiple uses, we've already seen it used to perform the modulo function with numbers (i.e. giving the remainder after whole number division e.g. 9 % 4 gives 1, 12 % 5 gives 2), but with strings, \"%\" performs string interpolation. **Interpolation** in this case roughly means filling in the gaps. It consists of a string on the left hand side specifying the conversion specs, such as \n",
    "\n",
    "    form = 'Does %s like %s ??'\n",
    "    \n",
    "where \"%s\" means insert something here, specifically a string. We also need to specify a tuple of values for insertion, one for each spec:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "form = 'Does %s like %s ??'\n",
    "form % ('Bill','eggs')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"%s\" is not the only conversion spec. Other options include \"%d\" and \"%f\". \"%d\" is used for integers and can be used to give an item a width of at least N characters, pad with spaces on the left etc. It can be used to print aligned columns of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [7, 344, 12]\n",
    "for i in x:\n",
    "    print ('|%5d|' % (i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"%f\" is used for floats. In the form \n",
    "\n",
    "    %N:Mf\n",
    "\n",
    "*M* gives the precision i.e. number of places printed after decimal point. Python will truncate, or pad with zeros, to get this many places, and it will round place up, e.g.  0.6666 to 0.67. *N* gives (min) overall width (width includes decimal point and places after)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [7.66666, 343.2, 11.12]\n",
    "for i in x:\n",
    "    print ('|%10.3f|' % (i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you follow the formatting in the following example?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "densities = [('aluminium', 2.70), ('gold', 19.3), ('magnesium', 1.738)]\n",
    "for (metal,density) in densities:\n",
    "    print ('%10s has density %5.2f grams cubic cm' % (metal, density))\n",
    "for (metal,density) in densities:\n",
    "    print ('the metal with density %5.2f g/cc is %s' % (density, metal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File Input / Output\n",
    "\n",
    "A connection to a named file, for reading or writing, can be opened using\n",
    "\n",
    "    open(<filename>,<mode>)\n",
    "\n",
    "This creates and returns a file object which stores connection information\n",
    "\n",
    "    f = open('foo.txt','r')  # read only\n",
    "    f = open('foo.txt','w')  # write only\n",
    "    f = open('foo.txt','a')  # append only\n",
    "\n",
    "The default mode is 'r', i.e. if you call \n",
    "\n",
    "    f = open('foo.txt')\n",
    "\n",
    "it will be open in read only mode. There are two options for mode 'w':\n",
    "\n",
    "- if the file did not exist, it is newly created as an empty file\n",
    "- if it did exit, then it is overwritten (so you now have an empty file)\n",
    "\n",
    "Depending on the mode of opening, file objects have various methods available\n",
    "\n",
    "    f.readline()   # read line from file\n",
    "    f.read()       # careful: may swallow big file in one!\n",
    "    f.write(s)     # write string s to file\n",
    "    f.close()      # close file\n",
    "    \n",
    "By default, the standard print command prints to the *standard output stream* (a.k.a.) **stdout**. In Python, this is a special stream called sys.stdout. We can also direct output of print to a file object:\n",
    "\n",
    "    f = open('foo.txt','w')\n",
    "    print ('Hello world', file = f)\n",
    "    \n",
    "We saw in notebook 4 that we can use a simple **for** loop to read lines of text from a file \n",
    "\n",
    "    f = open('foo.txt','r')\n",
    "    for line in f:\n",
    "    print (line, end = \"\")\n",
    "\n",
    "With each iteration of the *for*-loop, the loop variable (line) is assigned the next line of text from the file. This is a clean and readable way to code reading from a file and this approach is recommended as being preferable to alternatives (e.g. f.readlines()) unless a more complicated approach is required by the task.\n",
    "\n",
    "How does the following cell change the input file? Change the content so the output is produced to screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inf = open('files/rhyme.txt','r')      # open input file\n",
    "out = open('files/new.txt','w')         # open output file\n",
    "num=0\n",
    "\n",
    "for line in inf:           # read input file, line by line\n",
    "    num = num + 1\n",
    "    print ('[%d] %s' % (num,line), end = \"\", file=out) # print num/line out\n",
    "\n",
    "inf.close()                          # close input file stream\n",
    "out.close()                          # close output file stre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filestreams often handled using a\n",
    "\n",
    "    with ... as ...\n",
    "\n",
    "construct. This executes the open command and assigns to a variable. The filestream automatically closes when the code block exits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "with open(\"files/rhyme.txt\",'r') as infile:\n",
    "    num = 0\n",
    "    for line in infile:\n",
    "        num += 1\n",
    "        print (num, line, end = \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard input, output and error streams are available from the **sys module** as *sys.stdin*, *sys.stdout* and *sys.stderr*. We must first\n",
    "\n",
    "    import sys\n",
    "\n",
    "Streams have similar methods to file objects, e.g. you can write string *s* to error stream with:\n",
    "\n",
    "    sys.stderr.write(s)\n",
    "\n",
    "We can direct the output of print a statement to (e.g.) the error stream\n",
    "\n",
    "    print ('Hello World!', file = sys.stderr)\n",
    "\n",
    "or, as shown above, to a file (object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "f = open('file/new.txt','w')\n",
    "print ('Hello World!', file = f)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}