Programming Python (5 page)

^[
2
]
No, I’m serious. In the Python classes I teach, I had for many
years regularly used the name “Bob Smith,” age 40.5, and jobs
“developer” and “manager” as a supposedly fictitious database
record—until a class in Chicago, where I met a student named Bob
Smith, who was 40.5 and was a developer and manager. The world is
stranger than it seems.

So that we
don’t have to keep working interactively, let’s first
write a script that initializes the data we are going to store (if
you’ve done any Python work in the past, you know that the interactive
prompt tends to become tedious once you leave the realm of simple
one-liners).
Example 1-1
creates
the sort of records and database dictionary we’ve been working with so
far, but because it is a module, we can import it repeatedly without
having to retype the code each time. In a sense, this module is a
database itself, but its program code format doesn’t support automatic
or end-user updates as is.

# initialize data to be stored in files, pickles, shelves
# records
bob = {'name': 'Bob Smith', 'age': 42, 'pay': 30000, 'job': 'dev'}
sue = {'name': 'Sue Jones', 'age': 45, 'pay': 40000, 'job': 'hdw'}
tom = {'name': 'Tom',       'age': 50, 'pay': 0,     'job': None}
# database
db = {}
db['bob'] = bob
db['sue'] = sue
db['tom'] = tom
if __name__ == '__main__':       # when run as a script
for key in db:
print(key, '=>\n  ', db[key])

As usual, the
__name__
test
at the bottom of
Example 1-1
is
true only when this file is run, not when it is imported. When run as
a top-level script (e.g., from a command line, via an icon click, or
within the IDLE GUI), the file’s self-test code under this test dumps
the database’s contents to the standard output stream (remember,
that’s what
print
function-call
statements do by default).

Here is the script in action being run from a system command
line on Windows. Type the following command in a Command Prompt window
after a
cd
to the directory where
the file is stored, and use a similar console window on other types of
computers:

...\PP4E\Preview>
python initdata.py
bob =>
{'job': 'dev', 'pay': 30000, 'age': 42, 'name': 'Bob Smith'}
sue =>
{'job': 'hdw', 'pay': 40000, 'age': 45, 'name': 'Sue Jones'}
tom =>
{'job': None, 'pay': 0, 'age': 50, 'name': 'Tom'}

Since this is our
first source file (a.k.a. “script”), here are three
usage notes for this book’s examples:

We’ll use these conventions throughout the book; see the Preface
for more on getting the examples if you wish to work along. I
occasionally give more of the directory path in system prompts when
it’s useful to provide the extra execution context, especially in the
system part of the book (e.g., a “C:\” prefix from Windows or more
directory names).

I gave
pointers for using the interactive prompt earlier. Now
that we’ve started running script files, here are also a few quick
startup pointers for using Python scripts in general:

I’ll assume here that you’re able to run Python code one way or
another. Again, if you’re stuck, see other books such as
Learning
Python
for the full story on launching Python
programs.

Now, all we
have to do is store all of this in-memory data in a
file. There are a variety of ways to accomplish this; one of the most
basic is to write one piece of data at a time, with separators between
each that we can use when reloading to break the data apart.
Example 1-2
shows one way to code
this idea.

"""
Save in-memory database object to a file with custom formatting;
assume 'endrec.', 'enddb.', and '=>' are not used in the data;
assume db is dict of dict;  warning: eval can be dangerous - it
runs strings as code;  could also eval() record dict all at once;
could also dbfile.write(key + '\n') vs print(key, file=dbfile);
"""
dbfilename = 'people-file'
ENDDB  = 'enddb.'
ENDREC = 'endrec.'
RECSEP = '=>'
def storeDbase(db, dbfilename=dbfilename):
"formatted dump of database to flat file"
dbfile = open(dbfilename, 'w')
for key in db:
print(key, file=dbfile)
for (name, value) in db[key].items():
print(name + RECSEP + repr(value), file=dbfile)
print(ENDREC, file=dbfile)
print(ENDDB, file=dbfile)
dbfile.close()
def loadDbase(dbfilename=dbfilename):
"parse data to reconstruct database"
dbfile = open(dbfilename)
import sys
sys.stdin = dbfile
db = {}
key = input()
while key != ENDDB:
rec = {}
field = input()
while field != ENDREC:
name, value = field.split(RECSEP)
rec[name] = eval(value)
field = input()
db[key] = rec
key = input()
return db
if __name__ == '__main__':
from initdata import db
storeDbase(db)

This is a somewhat complex program, partly because it has both
saving and loading logic and partly because it does its job the hard
way; as we’ll see in a moment, there are better ways to get objects
into files than by manually formatting and parsing them. For simple
tasks, though, this does work; running
Example 1-2
as a script writes the
database out to a flat file. It has no printed output, but we can
inspect the database file interactively after this script is run,
either within IDLE or from a console window where you’re running these
examples (as is, the database file shows up in the current working
directory):

...\PP4E\Preview>
python make_db_file.py
...\PP4E\Preview>
python
>>>
for line in open('people-file'):
...
print(line, end='')
...
bob
job=>'dev'
pay=>30000
age=>42
name=>'Bob Smith'
endrec.
sue
job=>'hdw'
pay=>40000
age=>45
name=>'Sue Jones'
endrec.
tom
job=>None
pay=>0
age=>50
name=>'Tom'
endrec.
enddb.

This file is simply our database’s content with added
formatting. Its data originates from the test data initialization
module we wrote in
Example 1-1
because that is the module from which
Example 1-2
’s self-test code imports
its data. In practice,
Example 1-2
itself could be imported
and used to store a variety of databases and files.

Notice how data to be written is formatted with the as-code
repr
call and is re-created with
the
eval
call, which treats strings
as Python code. That allows us to store and re-create things like the
None
object, but it is potentially
unsafe; you shouldn’t use
eval
if
you can’t be sure that the database won’t contain malicious code. For
our purposes, however, there’s probably no cause for
alarm.

To test
further,
Example 1-3
reloads the database
from a file each time it is run.

from make_db_file import loadDbase
db = loadDbase()
for key in db:
print(key, '=>\n  ', db[key])
print(db['sue']['name'])

And
Example 1-4
makes
changes by loading, updating, and storing again.

from make_db_file import loadDbase, storeDbase
db = loadDbase()
db['sue']['pay'] *= 1.10
db['tom']['name'] = 'Tom Tom'
storeDbase(db)

Here are the dump script and the update script in action at a
system command line; both Sue’s pay and Tom’s name change between
script runs. The main point to notice is that the data stays around
after each script exits—our objects have become persistent simply
because they are mapped to and from text files:

...\PP4E\Preview>
python dump_db_file.py
bob =>
{'pay': 30000, 'job': 'dev', 'age': 42, 'name': 'Bob Smith'}
sue =>
{'pay': 40000, 'job': 'hdw', 'age': 45, 'name': 'Sue Jones'}
tom =>
{'pay': 0, 'job': None, 'age': 50, 'name': 'Tom'}
Sue Jones
...\PP4E\Preview>
python update_db_file.py
...\PP4E\Preview>
python dump_db_file.py
bob =>
{'pay': 30000, 'job': 'dev', 'age': 42, 'name': 'Bob Smith'}
sue =>
{'pay':
44000.0
, 'job': 'hdw', 'age': 45, 'name': 'Sue Jones'}
tom =>
{'pay': 0, 'job': None, 'age': 50, 'name':
'Tom Tom'
}
Sue Jones

As is, we’ll have to write Python code in scripts or at the
interactive command line for each specific database update we need to
perform (later in this chapter, we’ll do better by providing
generalized console, GUI, and web-based interfaces instead). But at a
basic level, our text file is a database of records. As we’ll learn in
the next section, though, it turns out that we’ve just done a lot of
pointless
work.

Example 1-5. PP4E\Preview\make_db_pickle.py

from initdata import db
import pickle
dbfile = open('people-pickle', 'wb')               # use binary mode files in 3.X
pickle.dump(db, dbfile)                            # data is bytes, not str
dbfile.close()

Example 1-6. PP4E\Preview\dump_db_pickle.py

import pickle
dbfile = open('people-pickle', 'rb')               # use binary mode files in 3.X
db = pickle.load(dbfile)
for key in db:
print(key, '=>\n  ', db[key])
print(db['sue']['name'])

Example 1-7. PP4E\Preview\update-db-pickle.py

import pickle
dbfile = open('people-pickle', 'rb')
db = pickle.load(dbfile)
dbfile.close()
db['sue']['pay'] *= 1.10
db['tom']['name'] = 'Tom Tom'
dbfile = open('people-pickle', 'wb')
pickle.dump(db, dbfile)
dbfile.close()