html-008/cfbook008.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
            "http://www.w3.org/TR/REC-html40/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="GENERATOR" content="hevea 1.07" />
<title>
Files
</title>
</head>
<body>
<a href="cfbook007.html"><img src="previous_motif.gif" alt="Previous" /></a>
<a href="index.html"><img src="contents_motif.gif" alt="Up" /></a>
<a href="cfbook009.html"><img src="next_motif.gif" alt="Next" /></a>
<hr />
<h1><font color="black"><a name="htoc87">Chapter&nbsp;7</a>&nbsp;&nbsp;Files</font></h1>
<a name="@default412"></a>
<a name="@default413"></a>
<a name="toc80"></a>
<h2><font color="black"><a name="htoc88">7.1</a>&nbsp;&nbsp;Persistence</font></h2>
<a name="@default414"></a>
<a name="@default415"></a>
<font color="black">So far, we have learned how to write programs and communicate 
our intentions to the <b>Central Processing Unit</b> using conditional
execution, functions, and iterations. We have learned how to 
create and use data structures in the <b>Main Memory</b>. The CPU 
and memory are where our software works and runs. It is where 
all of the "thinking" happens. <br />
<br />
But if you recall from our hardware architecture discussions,
once the power is turned off, anything stored in either
the CPU or main memory is erased. So up to now, our
programs have just been transient fun exercises to learn Python.<br />
</font><div align="center"><font color="black"><img src="cfbook010.png" /></font></div><font color="black">
<br />
In this chapter, we start to work with <b>Secondary Memory</b> 
(or files).
Secondary memory is not erased even when the power is turned off. 
Or in the case of a USB flash drive, the
data can we write from our programs can be removed from the 
system and transported to another system.<br />
<br />
We will primarily focus on reading and writing text files such as 
those we create in a text editor. Later we will see how to work
with database files which are binary files, specifically designed to be read
and written through database software.</font><br />
<br />
<a name="toc81"></a>
<h2><font color="black"><a name="htoc89">7.2</a>&nbsp;&nbsp;Opening files</font></h2>
<a name="@default416"></a>
<a name="@default417"></a>
<a name="@default418"></a>
<font color="black">When we want to read or write a file (say on your hard drive), we first
must <b>open</b> the file. Opening the file communicates with your operating
system which knows where the data for each file is stored. When you open
a file, you are asking the operating system to find the file by name
and make sure the file exists. In this example, we open the file 
<tt>mbox.txt</tt> which should be stored in the same folder that you
are in when you 
start Python.
You can download this file from 
<tt>www.py4inf.com/code/mbox.txt</tt></font>
<pre><font size="4" color="blue">
&gt;&gt;&gt; fhand = open('mbox.txt')
&gt;&gt;&gt; print fhand
&lt;open file 'mbox.txt', mode 'r' at 0x1005088b0&gt;
</font></pre><a name="@default419"></a><font color="black">
If the <tt>open</tt> is successful, the operating system returns us a 
<b>file handle</b>. The file handle is not the actual data contained
in the file, but instead it is a "handle" that we can use to 
read the data. You are given a handle if the requested file
exists and you have the proper permissions to read the file.<br />
</font><div align="center"><font color="black"><img src="cfbook011.png" /></font></div><font color="black">
<br />
If the file does not exist, <tt>open</tt> will fail with a traceback and you 
will not get a handle to access the contents of the file:
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; fhand = open('stuff.txt')
Traceback (most recent call last):
  File "&lt;stdin&gt;", line 1, in &lt;module&gt;
IOError: [Errno 2] No such file or directory: 'stuff.txt'
</font></pre><font color="black">Later we will use <tt>try</tt> and <tt>except</tt> to deal more gracefully
with the situation where we attempt to open a file that does 
not exist.</font><br />
<br />
<a name="toc82"></a>
<h2><font color="black"><a name="htoc90">7.3</a>&nbsp;&nbsp;Text files and lines</font></h2>
<font color="black">A text file can be thought of as a sequence of lines, much like a Python
string can be thought of as a sequence of characters. For example, this
is a sample of a text file which records mail activity from various
individuals in an open source project development team:
</font><pre><font size="4" color="blue">
From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008
Return-Path: &lt;postmaster@collab.sakaiproject.org&gt;
Date: Sat, 5 Jan 2008 09:12:18 -0500
To: source@collab.sakaiproject.org
From: stephen.marquard@uct.ac.za
Subject: [sakai] svn commit: r39772 - content/branches/
Details: http://source.sakaiproject.org/viewsvn/?view=rev&amp;rev=39772
...
</font></pre><font size="4">
</font><font color="black"><font size="3">The entire file of mail interactions is available from 
<tt>www.py4inf.com/code/mbox.txt</tt></font> 
and a shortened version of the file is available from
<tt>www.py4inf.com/code/mbox-short.txt</tt>.
These files are in a standard format for a file containing 
multiple mail messages. The lines which start with 
"From " separate the messages and the lines which start 
with "From:" are part of the messages. 
For more information, see 
<tt>en.wikipedia.org/wiki/Mbox</tt>. <br />
<br />
To break the file into lines, there is a special character that 
represents the "end of the line" called the <b>newline</b> character.<br />
<br />
<a name="@default420"></a>
In Python, we represent the <b>newline</b> character as a backslash-n in 
string constants. Even though this looks like two characters, it
is actually a single character. When we look at the variable by entering
"stuff" in the interpreter, it shows us the <code>\n</code> in the string, 
but when we use <tt>print</tt> to show the string, we see the string broken
into two lines by the newline character.
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; stuff = 'Hello\nWorld!'
&gt;&gt;&gt; stuff
'Hello\nWorld!'
&gt;&gt;&gt; print stuff
Hello
World!
&gt;&gt;&gt; stuff = 'X\nY'
&gt;&gt;&gt; print stuff
X
Y
&gt;&gt;&gt; len(stuff)
3
</font></pre>
<font color="black">You can also see that the length of the string <code>'X\nY'</code> is <em>three</em>
characters because the newline character is a single character.<br />
<br />
So when we look at the lines in a file, we need to <em>imagine</em>
that there is a special invisible character at the end of each line
that marks the end of the line called the newline. <br />
<br />
So the newline character separates the characters 
in the file into lines.</font><br />
<br />
<a name="toc83"></a>
<h2><font color="black"><a name="htoc91">7.4</a>&nbsp;&nbsp;Reading files</font></h2>
<a name="@default421"></a>
<a name="@default422"></a><font color="black">
While the <b>file handle</b> does not contain the data for the file,
it is quite easy to construct a <tt>for</tt> loop to read through 
and count each of the lines in a file:
</font><pre><font size="4" color="blue">
fhand = open('mbox.txt')
count = 0
for line in fhand:
    count = count + 1
print 'Line Count:', count

python open.py 
Line Count: 132045
</font></pre><font color="black">We can use the file handle as the sequence in our <tt>for</tt> loop. 
Our <tt>for</tt> loop simply counts the number of lines in the 
file and prints them out. The rough translation of the <tt>for</tt>
loop into English is, "for each line in the file represented by the file
handle, add one to the <tt>count</tt> variable."<br />
<br />
The reason that the <tt>open</tt> function does not read the entire file
is that the file might be quite large with many gigabytes of data.
The <tt>open</tt> statement takes the same amount of time regardless of the
size of the file. The <tt>for</tt> loop actually causes the data to be 
read from the file.<br />
<br />
When the file is read using a <tt>for</tt> loop in this manner, Python
takes care of splitting the data in the file into separate lines using
the newline character. Python reads each line through 
the newline and includes
the newline as the last character in the <tt>line</tt> variable for each 
iteration of the <tt>for</tt> loop.<br />
<br />
Because the for loop reads the data one line at a time, it can efficiently
read and count the lines in very large files without running 
out of main memory to store the data. The above program can 
count the lines in any size file using very little memory since 
each line is read, counted, and then discarded.<br />
<br />
If you know the file is relatively small compared to the size of 
your main memory, you can read the whole file into one string
using the <tt>read</tt> method on the file handle.
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; fhand = open('mbox-short.txt')
&gt;&gt;&gt; inp = fhand.read()
&gt;&gt;&gt; print len(inp)
94626
&gt;&gt;&gt; print inp[:20]
From stephen.marquar
</font></pre><font color="black">In this example, the entire contents (all 94,626 characters) 
of the file <tt>mbox-short.txt</tt> are read directly into the 
variable <tt>inp</tt>. We use string slicing to print out the first
20 characters of the string data stored in <tt>inp</tt>.<br />
<br />
When the file is read in this manner, all the characters including 
all of the lines and newline characters are one big string 
in the variable <b>inp</b>. 
Remember that this form of the <tt>open</tt> function should only be used
if the file data will fit comfortably in the main memory 
of your computer.<br />
<br />
If the file is too large to fit in main memory, you should write
your program to read the file in chunks using a <tt>for</tt> or <tt>while</tt>
loop.</font><br />
<br />
<a name="toc84"></a>
<h2><font color="black"><a name="htoc92">7.5</a>&nbsp;&nbsp;Searching through a file</font></h2>
<font color="black">When you are searching through data in a file, it
is a very common pattern to read through a file, ignoring most
of the lines and only processing lines which meet a particular criteria.
We can combine the pattern for reading a file with string <b>methods</b>
to build simple search mechanisms.<br />
<br />
<a name="@default423"></a>
<a name="@default424"></a>
For example, if we wanted to read a file and only print out lines
which started with the prefix "From:", we could use the 
string method <b>startswith</b> to select only those lines with
the desired prefix:
</font><pre><font size="4" color="blue">
fhand = open('mbox-short.txt')
for line in fhand:
    if line.startswith('From:') :
        print line
</font></pre><font color="black">When this program runs, we get the following output:
</font><pre><font size="4" color="blue">
From: stephen.marquard@uct.ac.za

From: louis@media.berkeley.edu

From: zqian@umich.edu

From: rjlowe@iupui.edu
...
</font></pre><font color="black">The output looks great since the only lines we are seeing are those 
which start with "From:", but why are we seeing the extra blank
lines? This is due to that invisible <b>newline</b> character.
Each of the lines ends with a newline, so the <tt>print</tt> 
statement prints the string in the variable <b>line</b> which includes
a newline and then <tt>print</tt> adds <em>another</em> newline, resulting
in the double spacing effect we see.<br />
<br />
We could use line slicing to print all but the last character, but 
a simpler approach is to use the <b>rstrip</b> method which strips
whitespace from the right side of a string as follows:
</font><pre><font size="4" color="blue">
fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    if line.startswith('From:') :
        print line
</font></pre><font color="black">When this program runs, we get the following output:
</font><pre><font size="4" color="blue">
From: stephen.marquard@uct.ac.za
From: louis@media.berkeley.edu
From: zqian@umich.edu
From: rjlowe@iupui.edu
From: zqian@umich.edu
From: rjlowe@iupui.edu
From: cwen@iupui.edu
...
</font></pre><font color="black">As your file processing programs get more complicated, you may want 
to structure your search loops using <tt>continue</tt>. The basic idea 
of the search loop is that you are looking for "interesting" lines
and effectively skipping "uninteresting" lines. And then when we
find an interesting line, we do something with that line.<br />
<br />
We can structure the loop to follow the
pattern of skipping uninteresting lines as follows:
</font><pre><font size="4" color="blue">
fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    # Skip 'uninteresting lines'
    if not line.startswith('From:') :
        continue
    # Process our 'interesting' line
    print line
</font></pre><font color="black">The output of the program is the same. In English, the 
uninteresting lines are those which do not start 
with "From:", which we skip using <tt>continue</tt>.
For the "interesting" lines (i.e. those that start with "From:")
we perform the processing on those lines.<br />
<br />
We can use the <tt>find</tt> string method to simulate a text editor
search which finds lines where the search string is anywhere in the line. 
Since <tt>find</tt> looks for an occurrence of a string within another
string and either returns the position of the string or -1 if the string
was not found, we can write the following loop to show lines which
contain the string "@uct.ac.za" (i.e. they come from the University 
of Cape Town in South Africa):
</font><pre><font size="4" color="blue">
fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    if line.find('@uct.ac.za') == -1 : 
        continue
    print line
</font></pre><font color="black">Which produces the following output:
</font><pre><font size="4" color="blue">
From stephen.marquard@uct.ac.za Sat Jan  5 09:14:16 2008
X-Authentication-Warning: set sender to stephen.marquard@uct.ac.za using -f
From: stephen.marquard@uct.ac.za
Author: stephen.marquard@uct.ac.za
From david.horwitz@uct.ac.za Fri Jan  4 07:02:32 2008
X-Authentication-Warning: set sender to david.horwitz@uct.ac.za using -f
From: david.horwitz@uct.ac.za
Author: david.horwitz@uct.ac.za
...
</font></pre>
<a name="toc85"></a>
<h2><font color="black"><a name="htoc93">7.6</a>&nbsp;&nbsp;Letting the user choose the file name</font></h2>
<font color="black">We really do not want to have to edit our Python code
every time we want to process a different file. It would 
be more usable to ask the user to enter the file name string 
each time the program runs so they can use our 
program on different files without changing the Python code.<br />
<br />
This is quite simple to do by reading the file name from
the user using <code>raw_input</code> as follows:
</font><pre><font size="4" color="blue">
fname = raw_input('Enter the file name: ')
fhand = open(fname)
count = 0
for line in fhand:
    if line.startswith('Subject:') :
        count = count + 1
print 'There were', count, 'subject lines in', fname
</font></pre><font color="black">We read the file name from the user and place it in a variable
named <tt>fname</tt> and open that file. Now we can run the program 
repeatedly on different files.
</font><pre><font size="4" color="blue">
python search6.py 
Enter the file name: mbox.txt
There were 1797 subject lines in mbox.txt

python search6.py 
Enter the file name: mbox-short.txt
There were 27 subject lines in mbox-short.txt
</font></pre><font color="black">Before peeking at the next section, take a look at the above program
and ask yourself, "What could go possibly wrong here?" or "What might our
friendly user do that would cause our nice little program to 
ungracefully exit with a traceback, making us look not-so-cool 
in the eyes of our users?".</font><br />
<br />
<a name="toc86"></a>
<h2><font color="black"><a name="htoc94">7.7</a>&nbsp;&nbsp;Using <tt>try, except,</tt> and <tt>open</tt></font></h2>
<font color="black">I told you not to peek. This is your last chance.<br />
<br />
What if our user types something that is not a file name?
</font><pre><font size="4" color="blue">
python search6.py 
Enter the file name: missing.txt
Traceback (most recent call last):
  File "search6.py", line 2, in &lt;module&gt;
    fhand = open(fname)
IOError: [Errno 2] No such file or directory: 'missing.txt'

python search6.py 
Enter the file name: na na boo boo
Traceback (most recent call last):
  File "search6.py", line 2, in &lt;module&gt;
    fhand = open(fname)
IOError: [Errno 2] No such file or directory: 'na na boo boo'
</font></pre><font color="black">Do not laugh, users will eventually do every possible thing they can do 
to break your programs --- either on purpose or with malicious intent.
As a matter of fact, an important part of any software development
team is a person or group called <b>Quality Assurance</b> (or QA for short)
whose very job it is to do the craziest things possible in an attempt
to break the software that the programmer has created.<br />
<br />
<a name="@default425"></a>
<a name="@default426"></a>
The QA team is responsible for finding the flaws in programs before 
we have delivered the program to the end-users who may be purchasing the
software or paying our salary to write the software. So the QA team
is the programmer's best friend.<br />
<br />
<a name="@default427"></a>
<a name="@default428"></a>
<a name="@default429"></a>
<a name="@default430"></a>
<a name="@default431"></a>
<a name="@default432"></a>
So now that we see the flaw in the program, we can elegantly fix it using
the <tt>try</tt>/<tt>except</tt> structure. We need to assume that the <tt>open</tt>
call might fail and add recovery code when the <tt>open</tt> fails
as follows:
</font><pre><font size="4" color="blue">
fname = raw_input('Enter the file name: ')
try:
    fhand = open(fname)
except:
    print 'File cannot be opened:', fname
    exit()

count = 0
for line in fhand:
    if line.startswith('Subject:') : 
        count = count + 1
print 'There were', count, 'subject lines in', fname
</font></pre><font color="black">The <tt>exit</tt> function terminates the program. It is a function
that we call that never returns. Now when our user (or 
QA team) types in silliness or bad file names, 
we "catch" them and recover gracefully:
</font><pre><font size="4" color="blue">
python search7.py
Enter the file name: mbox.txt
There were 1797 subject lines in mbox.txt

python search7.py
Enter the file name: na na boo boo
File cannot be opened: na na boo boo
</font></pre><a name="@default433"></a><font color="black">
Protecting the <tt>open</tt> call is a good example 
of the proper use of <tt>try</tt>
and <tt>except</tt> in a Python program. We use the term
"Pythonic" when we are doing something the "Python
way". We might say that the above example is 
the Pythonic way to open a file.<br />
<br />
Once you become more skilled in Python, you can engage
in repartee' with other Python programmers to decide
which of two equivalent solutions to a problem is 
"more Pythonic". The goal to be "more Pythonic" 
captures the notion that programming is part engineering
and part art. We are not always interested
in just making something work, we also want
our solution to be elegant and to be appreciated as 
elegant by our peers.</font><br />
<br />
<a name="toc87"></a>
<h2><font color="black"><a name="htoc95">7.8</a>&nbsp;&nbsp;Writing files</font></h2>
<a name="@default434"></a>
<font color="black">To write a file, you have to open it with mode
<code>'w'</code> as a second parameter:
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; fout = open('output.txt', 'w')
&gt;&gt;&gt; print fout
&lt;open file 'output.txt', mode 'w' at 0xb7eb2410&gt;
</font></pre><font color="black">If the file already exists, opening it in write mode clears out
the old data and starts fresh, so be careful!
If the file doesn't exist, a new one is created.<br />
<br />
The <tt>write</tt> method of the file handle object 
puts data into the file.
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; line1 = 'This here's the wattle,\n'
&gt;&gt;&gt; fout.write(line1)
</font></pre><a name="@default435"></a><font color="black">
Again, the file object keeps track of where it is, so if
you call <tt>write</tt> again, it adds the new data to the end.<br />
<br />
We must make sure to manage the ends of lines as we write
to the file by explicitly inserting the newline character
when we want to end a line. The <tt>print</tt> statement 
automatically appends a newline, but the <tt>write</tt> 
method does not add the newline automatically.
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; line2 = 'the emblem of our land.\n'
&gt;&gt;&gt; fout.write(line2)
</font></pre><font color="black">When you are done writing, you have to close the file
to make sure that the last bit of data is physically written
to the disk so it will not be lost if the power goes off.
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; fout.close()
</font></pre><font color="black">We could close the files which we open for read as well, 
but we can be a little sloppy if we are only opening a few
files since Python makes sure that all open files are 
closed when the program ends. When we are writing files, 
we want to explicitly close the files so as to leave nothing
to chance.</font><br />
<br />
<a name="@default436"></a>
<a name="@default437"></a><br />
<br />
<a name="toc88"></a>
<h2><font color="black"><a name="htoc96">7.9</a>&nbsp;&nbsp;Debugging</font></h2>
<a name="@default438"></a>
<a name="@default439"></a>
<font color="black">When you are reading and writing files, you might run into problems
with whitespace. These errors can be hard to debug because spaces,
tabs and newlines are normally invisible:
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; s = '1 2\t 3\n 4'
&gt;&gt;&gt; print s
1 2  3
 4
</font></pre>
<a name="@default440"></a>
<a name="@default441"></a>
<a name="@default442"></a>
<font color="black">The built-in function <tt>repr</tt> can help. It takes any object as an
argument and returns a string representation of the object. For
strings, it represents whitespace
characters with backslash sequences:
</font><pre><font size="4" color="blue">
&gt;&gt;&gt; print repr(s)
'1 2\t 3\n 4'
</font></pre>
<font color="black">This can be helpful for debugging.<br />
<br />
One other problem you might run into is that different systems
use different characters to indicate the end of a line. Some
systems use a newline, represented <code>\n</code>. Others use
a return character, represented <code>\r</code>. Some use both.
If you move files between different systems, these inconsistencies
might cause problems.<br />
<br />
<a name="@default443"></a><br />
<br />
For most systems, there are applications to convert from one
format to another. You can find them (and read more about this
issue) at <tt>wikipedia.org/wiki/Newline</tt>. Or, of course, you
could write one yourself.</font><br />
<br />
<a name="toc89"></a>
<h2><font color="black"><a name="htoc97">7.10</a>&nbsp;&nbsp;Glossary</font></h2>
<dl compact="compact"><dt><font color="black"><b>catch:</b></font></dt><dd><font color="black"> To prevent an exception from terminating
a program using the <tt>try</tt>
and <tt>except</tt> statements.
</font><a name="@default444"></a><br />
<br />
</dd><dt><font color="black"><b>newline:</b></font></dt><dd><font color="black"> A special character used in files and strings to indicate
the end of a line.
</font><a name="@default445"></a><br />
<br />
</dd><dt><font color="black"><b>Pythonic:</b></font></dt><dd><font color="black"> A technique that works elegantly in Python.
"Using try and except is the <em>Pythonic</em> way to recover from 
missing files.".
</font><a name="@default446"></a><br />
<br />
</dd><dt><font color="black"><b>Quality Assurance:</b></font></dt><dd><font color="black"> A person or team focused on insuring the 
overall quality of a software product. QA is often involved 
in testing a product and identifying problems before the product 
is released.
</font><a name="@default447"></a>
<a name="@default448"></a><br />
<br />
</dd><dt><font color="black"><b>text file:</b></font></dt><dd><font color="black"> A sequence of characters stored in permanent
storage like a hard drive.
</font><a name="@default449"></a></dd></dl>
<a name="toc90"></a>
<h2><font color="black"><a name="htoc98">7.11</a>&nbsp;&nbsp;Exercises</font></h2><br />
<div align="left"><font color="black"><b>Exercise&nbsp;1</b>&nbsp;&nbsp;<em>
Write a program to read through a file and print the contents 
of the file (line by line) all in upper case. Executing the program 
will look as follows:
</em></font><pre><font size="4" color="blue"><em>
python shout.py
Enter a file name: mbox-short.txt
FROM STEPHEN.MARQUARD@UCT.AC.ZA SAT JAN  5 09:14:16 2008
RETURN-PATH: &lt;POSTMASTER@COLLAB.SAKAIPROJECT.ORG&gt;
RECEIVED: FROM MURDER (MAIL.UMICH.EDU [141.211.14.90])
  BY FRANKENSTEIN.MAIL.UMICH.EDU (CYRUS V2.3.8) WITH LMTPA;
  SAT, 05 JAN 2008 09:14:16 -0500
</em></font></pre><font color="black"><em>You can download the file from
<tt>www.py4inf.com/code/mbox-short.txt</tt></em></font>
</div><br />
<div align="left"><font color="black"><b>Exercise&nbsp;2</b>&nbsp;&nbsp;<em>
Write a program 
to prompt for a file name, and then read through the file 
and look for lines of the form:
</em></font><pre><font color="blue" size="4"><em>
X-DSPAM-Confidence: <b> 0.8475</b>
</em></font></pre><font size="4">
</font><font size="3" color="black"><em>When you encounter a line that starts with 
"X-DSPAM-Confidence:" pull apart the line to extract the
floating point number on the line. Count these 
lines and the compute the total of the spam confidence 
values from these lines.
When you reach the end of the file, print out the average
spam confidence.
</em></font><pre><font size="4" color="blue"><em>
Enter the file name: mbox.txt
Average spam confidence: 0.894128046745

Enter the file name: mbox-short.txt
Average spam confidence: 0.750718518519
</em></font></pre><font color="black"><em>Test your file on the <tt>mbox.txt</tt> and <tt>mbox-short.txt</tt> files.
</em></font></div><br />
<div align="left"><font color="black"><b>Exercise&nbsp;3</b>&nbsp;&nbsp;<em>
Sometimes when programmers get bored or want to have a bit of fun,
they add a harmless <b>Easter Egg</b> to their program 
(<tt>en.wikipedia.org/wiki/Easter_egg_(media)</tt>). Modify the program
that prompts the user for the file name so that it prints a funny
message when the user types in the exact file name 'na na boo boo'. 
The program should behave normally for all other files which exist
and don't exist. Here is a sample execution of the program:
</em></font><pre><font size="4" color="blue"><em>
python egg.py 
Enter the file name: mbox.txt
There were 1797 subject lines in mbox.txt

python egg.py 
Enter the file name: missing.tyxt
File cannot be opened: missing.tyxt

python egg.py 
Enter the file name: na na boo boo
NA NA BOO BOO TO YOU - You have been punk'd!
</em></font></pre><font color="black"><em>We are not encouraging you to put Easter Eggs in your programs -
this is just an exercise.</em></font></div><br />
<hr />
<a href="cfbook007.html"><img src="previous_motif.gif" alt="Previous" /></a>
<a href="index.html"><img src="contents_motif.gif" alt="Up" /></a>
<a href="cfbook009.html"><img src="next_motif.gif" alt="Next" /></a>
</body>
</html>