GNU Info

(python2.1-lib.info)shelve

---

Next: copy Prev: copy_reg Up: Python Runtime Services

---

Enter node , (file) or (file)node

Python object persistence
=========================

Python object persistence.

A "shelf" is a persistent, dictionary-like object.  The difference with
"dbm" databases is that the values (not the keys!) in a shelf can be
essentially arbitrary Python objects -- anything that the `pickle'
module can handle.  This includes most class instances, recursive data
types, and objects containing lots of shared sub-objects.  The keys are
ordinary strings.

To summarize the interface (`key' is a string, `data' is an arbitrary
object):

     import shelve
     
     d = shelve.open(filename) # open, with (g)dbm filename -- no suffix
     
     d[key] = data   # store data at key (overwrites old data if
                     # using an existing key)
     data = d[key]   # retrieve data at key (raise KeyError if no
                     # such key)
     del d[key]      # delete data stored at key (raises KeyError
                     # if no such key)
     flag = d.has_key(key)   # true if the key exists
     list = d.keys() # a list of all existing keys (slow!)
     
     d.close()       # close it

Restrictions:

   * The choice of which database package will be used (e.g. `dbm' or
     `gdbm') depends on which interface is available.  Therefore it is
     not safe to open the database directly using `dbm'.  The database
     is also (unfortunately) subject to the limitations of `dbm', if it
     is used -- this means that (the pickled representation of) the
     objects stored in the database should be fairly small, and in rare
     cases key collisions may cause the database to refuse updates.

   * Dependent on the implementation, closing a persistent dictionary
     may or may not be necessary to flush changes to disk.

   * The `shelve' module does not support _concurrent_ read/write
     access to shelved objects.  (Multiple simultaneous read accesses
     are safe.)  When a program has a shelf open for writing, no other
     program should have it open for reading or writing.  UNIX file
     locking can be used to solve this, but this differs across UNIX
     versions and requires knowledge about the database implementation
     used.


See also:
     Note: anydbm Generic interface to `dbm'-style databases.  Note:
     dbhash BSD `db' database interface.  Note: dbm Standard UNIX
     database interface.  Note: dumbdbm Portable implementation of
     the `dbm' interface.  Note: gdbm GNU database interface, based
     on the `dbm' interface.  Note: pickle Object serialization used
     by `shelve'.  Note: cPickle High-performance version of `pickle'.