\section{\module{UserDict} ---         Class wrapper for dictionary objects} \declaremodule{standard}{UserDict}\modulesynopsis{Class wrapper for dictionary objects.}  The module defines a mixin,  \class{DictMixin}, defining all dictionarymethods for classes that already have a minimum mapping interface.  Thisgreatly simplifies writing classes that need to be substitutable fordictionaries (such as the shelve module). This also module defines a class, \class{UserDict}, that acts as a wrapperaround dictionary objects.  The need for this class has been largelysupplanted by the ability to subclass directly from \class{dict} (a featurethat became available starting with Python version 2.2).  Prior to theintroduction of \class{dict}, the \class{UserDict} class was used tocreate dictionary-like sub-classes that obtained new behaviors by overridingexisting methods or adding new ones. The \module{UserDict} module defines the \class{UserDict} classand \class{DictMixin}: \begin{classdesc}{UserDict}{\optional{initialdata}} Class that simulates a dictionary.  The instance's contents are keptin a regular dictionary, which is accessible via the \member{data}attribute of \class{UserDict} instances.  If \var{initialdata} isprovided, \member{data} is initialized with its contents; note that areference to \var{initialdata} will not be kept, allowing it be usedfor other purposes. \note{For backward compatibility, instances of\class{UserDict} are not iterable.}\end{classdesc} \begin{classdesc}{IterableUserDict}{\optional{initialdata}}Subclass of \class{UserDict} that supports direct iteration (e.g. \code{for key in myDict}).\end{classdesc} In addition to supporting the methods and operations of mappings (seesection \ref{typesmapping}), \class{UserDict} and\class{IterableUserDict} instances provide the following attribute: \begin{memberdesc}{data}A real dictionary used to store the contents of the \class{UserDict}class.\end{memberdesc} \begin{classdesc}{DictMixin}{}Mixin defining all dictionary methods for classes that already havea minimum dictionary interface including \method{__getitem__()},\method{__setitem__()}, \method{__delitem__()}, and \method{keys()}. This mixin should be used as a superclass.  Adding each of theabove methods adds progressively more functionality.  For instance,defining all but \method{__delitem__} will preclude only \method{pop}and \method{popitem} from the full interface. In addition to the four base methods, progressively more efficiencycomes with defining \method{__contains__()}, \method{__iter__()}, and\method{iteritems()}. Since the mixin has no knowledge of the subclass constructor, itdoes not define \method{__init__()} or \method{copy()}.\end{classdesc}  \section{\module{UserList} ---         Class wrapper for list objects} \declaremodule{standard}{UserList}\modulesynopsis{Class wrapper for list objects.}  \note{This module is available for backward compatibility only.  Ifyou are writing code that does not need to work with versions ofPython earlier than Python 2.2, please consider subclassing directlyfrom the built-in \class{list} type.} This module defines a class that acts as a wrapper aroundlist objects.  It is a useful base class foryour own list-like classes, which can inherit fromthem and override existing methods or add new ones.  In this way onecan add new behaviors to lists. The \module{UserList} module defines the \class{UserList} class: \begin{classdesc}{UserList}{\optional{list}}Class that simulates a list.  The instance'scontents are kept in a regular list, which is accessible via the\member{data} attribute of \class{UserList} instances.  The instance'scontents are initially set to a copy of \var{list}, defaulting to theempty list \code{[]}.  \var{list} can be either a regular Python list,or an instance of \class{UserList} (or a subclass).\end{classdesc} In addition to supporting the methods and operations of mutablesequences (see section \ref{typesseq}), \class{UserList} instancesprovide the following attribute: \begin{memberdesc}{data}A real Python list object used to store the contents of the\class{UserList} class.\end{memberdesc} \strong{Subclassing requirements:}Subclasses of \class{UserList} are expect to offer a constructor whichcan be called with either no arguments or one argument.  Listoperations which return a new sequence attempt to create an instanceof the actual implementation class.  To do so, it assumes that theconstructor can be called with a single parameter, which is a sequenceobject used as a data source. If a derived class does not wish to comply with this requirement, allof the special methods supported by this class will need to beoverridden; please consult the sources for information about themethods which need to be provided in that case. \versionchanged[Python versions 1.5.2 and 1.6 also required that the                constructor be callable with no parameters, and offer                a mutable \member{data} attribute.  Earlier versions                of Python did not attempt to create instances of the                derived class]{2.0}  \section{\module{UserString} ---         Class wrapper for string objects} \declaremodule{standard}{UserString}\modulesynopsis{Class wrapper for string objects.}\moduleauthor{Peter Funk}{pf@artcom-gmbh.de}\sectionauthor{Peter Funk}{pf@artcom-gmbh.de} \note{This \class{UserString} class from this module is available forbackward compatibility only.  If you are writing code that does notneed to work with versions of Python earlier than Python 2.2, pleaseconsider subclassing directly from the built-in \class{str} typeinstead of using \class{UserString} (there is no built-in equivalentto \class{MutableString}).} This module defines a class that acts as a wrapper around stringobjects.  It is a useful base class for your own string-like classes,which can inherit from them and override existing methods or add newones.  In this way one can add new behaviors to strings. It should be noted that these classes are highly inefficient comparedto real string or Unicode objects; this is especially the case for\class{MutableString}. The \module{UserString} module defines the following classes: \begin{classdesc}{UserString}{\optional{sequence}}Class that simulates a string or a Unicode stringobject.  The instance's content is kept in a regular string or Unicodestring object, which is accessible via the \member{data} attribute of\class{UserString} instances.  The instance's contents are initiallyset to a copy of \var{sequence}.  \var{sequence} can be either aregular Python string or Unicode string, an instance of\class{UserString} (or a subclass) or an arbitrary sequence which canbe converted into a string using the built-in \function{str()} function.\end{classdesc} \begin{classdesc}{MutableString}{\optional{sequence}}This class is derived from the \class{UserString} above and redefinesstrings to be \emph{mutable}.  Mutable strings can't be used asdictionary keys, because dictionaries require \emph{immutable} objects askeys.  The main intention of this class is to serve as an educationalexample for inheritance and necessity to remove (override) the\method{__hash__()} method in order to trap attempts to use amutable object as dictionary key, which would be otherwise veryerror prone and hard to track down.\end{classdesc} In addition to supporting the methods and operations of string andUnicode objects (see section \ref{string-methods}, ``StringMethods''), \class{UserString} instances provide the followingattribute: \begin{memberdesc}{data}A real Python string or Unicode object used to store the content of the\class{UserString} class.\end{memberdesc}