[Python-checkins] python/dist/src/Doc/lib libsets.tex,1.1,1.2
fdrake@users.sourceforge.net
fdrake@users.sourceforge.net
Fri, 23 Aug 2002 10:22:38 -0700
Update of /cvsroot/python/python/dist/src/Doc/lib
In directory usw-pr-cvs1:/tmp/cvs-serv3097
Modified Files:
libsets.tex
Log Message:
Adjust the markup in a few places so this will actually format.
Remove the third column in the tables since it isn't used.
Index: libsets.tex
===================================================================
RCS file: /cvsroot/python/python/dist/src/Doc/lib/libsets.tex,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** libsets.tex 23 Aug 2002 15:18:38 -0000 1.1
--- libsets.tex 23 Aug 2002 17:22:36 -0000 1.2
***************
*** 17,24 ****
difference.
! Like other collections, sets support \code{x in s}, \code{len(s)}, and
! \code{for x in s}. Being an unordered collection, sets do not record element
! position or order of insertion. Accordingly, sets do not support indexing,
! slicing or other sequence-like behavior.
Most set applications use the \class{Set} class which provides every set
--- 17,25 ----
difference.
! Like other collections, sets support \code{\var{x} in \var{set}},
! \code{len(\var{set})}, and \code{for \var{x} in \var{set}}. Being an
! unordered collection, sets do not record element position or order of
! insertion. Accordingly, sets do not support indexing, slicing, or
! other sequence-like behavior.
Most set applications use the \class{Set} class which provides every set
***************
*** 28,39 ****
\class{Set} and \class{ImmutableSet} derive from \class{BaseSet}, an
abstract class useful for determining whether something is a set:
! \code{isinstance(x, BaseSet)}.
! The set classes are implemented using dictionaries. As a result, sets cannot
! contain mutable elements such as lists or dictionaries. However, they can
! contain immutable collections such as tuples or instances of
! \class(ImmutableSet). For convenience in implementing sets of sets,
! inner sets are automatically converted to immutable form, for example,
! \code{Set([Set(['dog'])])} is transformed to
\code{Set([ImmutableSet(['dog'])])}.
--- 29,40 ----
\class{Set} and \class{ImmutableSet} derive from \class{BaseSet}, an
abstract class useful for determining whether something is a set:
! \code{isinstance(\var{obj}, BaseSet)}.
! The set classes are implemented using dictionaries. As a result, sets
! cannot contain mutable elements such as lists or dictionaries.
! However, they can contain immutable collections such as tuples or
! instances of \class(ImmutableSet). For convenience in implementing
! sets of sets, inner sets are automatically converted to immutable
! form, for example, \code{Set([Set(['dog'])])} is transformed to
\code{Set([ImmutableSet(['dog'])])}.
***************
*** 42,46 ****
parameter is supplied, updates the set with elements obtained from iteration.
All of the elements in \var{iterable} should be immutable or be transformable
! to an immutable using the protocol described at \ref{immutable-transforms}.
\end{classdesc}
--- 43,48 ----
parameter is supplied, updates the set with elements obtained from iteration.
All of the elements in \var{iterable} should be immutable or be transformable
! to an immutable using the protocol described in
! section~\ref{immutable-transforms}.
\end{classdesc}
***************
*** 49,54 ****
\var{iterable} parameter is supplied, updates the set with elements obtained
from iteration. All of the elements in \var{iterable} should be immutable or
! be transformable to an immutable using the protocol described at
! \ref{immutable-transforms}.
Because \class{ImmutableSet} objects provide a \method{__hash__()} method,
--- 51,56 ----
\var{iterable} parameter is supplied, updates the set with elements obtained
from iteration. All of the elements in \var{iterable} should be immutable or
! be transformable to an immutable using the protocol described in
! section~\ref{immutable-transforms}.
Because \class{ImmutableSet} objects provide a \method{__hash__()} method,
***************
*** 59,100 ****
! \subsection{set Objects}
Instances of \class{Set} and \class{ImmutableSet} both provide
the following operations:
! \begin{tableiii}{c|l|c}{code}{Operation}{Result}{Notes}
! \lineiii{len(\var{s})}{cardinality of set \var{s}}{}
\hline
! \lineiii{\var{x} in \var{s}}
! {test \var{x} for membership in \var{s}}{}
! \lineiii{\var{x} not in \var{s}}
! {test \var{x} for non-membership in \var{s}}{}
! \lineiii{\var{s}.issubset(\var{t})}
! {test whether every element in \var{s} is in \var{t}}{}
! \lineiii{\var{s}.issuperset(\var{t})}
! {test whether every element in \var{t} is in \var{s}}{}
\hline
! \lineiii{\var{s} | \var{t}}
! {new set with elements from both \var{s} and \var{t}}{}
! \lineiii{\var{s}.union(\var{t})}
! {new set with elements from both \var{s} and \var{t}}{}
! \lineiii{\var{s} & \var{t}}
! {new set with elements common to \var{s} and \var{t}}{}
! \lineiii{\var{s}.intersection(\var{t})}
! {new set with elements common to \var{s} and \var{t}}{}
! \lineiii{\var{s} - \var{t}}
! {new set with elements in \var{s} but not in \var{t}}{}
! \lineiii{\var{s}.difference(\var{t})}
! {new set with elements in \var{s} but not in \var{t}}{}
! \lineiii{\var{s} ^ \var{t}}
! {new set with elements in either \var{s} or \var{t} but not both}{}
! \lineiii{\var{s}.symmetric_difference(\var{t})}
! {new set with elements in either \var{s} or \var{t} but not both}{}
! \lineiii{\var{s}.copy()}
! {new set with a shallow copy of \var{s}}{}
! \end{tableiii}
In addition to the above operations, both \class{Set} and \class{ImmutableSet}
--- 61,102 ----
! \subsection{Set Objects}
Instances of \class{Set} and \class{ImmutableSet} both provide
the following operations:
! \begin{tableii}{c|l}{code}{Operation}{Result}
! \lineii{len(\var{s})}{cardinality of set \var{s}}
\hline
! \lineii{\var{x} in \var{s}}
! {test \var{x} for membership in \var{s}}
! \lineii{\var{x} not in \var{s}}
! {test \var{x} for non-membership in \var{s}}
! \lineii{\var{s}.issubset(\var{t})}
! {test whether every element in \var{s} is in \var{t}}
! \lineii{\var{s}.issuperset(\var{t})}
! {test whether every element in \var{t} is in \var{s}}
\hline
! \lineii{\var{s} | \var{t}}
! {new set with elements from both \var{s} and \var{t}}
! \lineii{\var{s}.union(\var{t})}
! {new set with elements from both \var{s} and \var{t}}
! \lineii{\var{s} \&\ \var{t}}
! {new set with elements common to \var{s} and \var{t}}
! \lineii{\var{s}.intersection(\var{t})}
! {new set with elements common to \var{s} and \var{t}}
! \lineii{\var{s} - \var{t}}
! {new set with elements in \var{s} but not in \var{t}}
! \lineii{\var{s}.difference(\var{t})}
! {new set with elements in \var{s} but not in \var{t}}
! \lineii{\var{s} \textasciicircum\ \var{t}}
! {new set with elements in either \var{s} or \var{t} but not both}
! \lineii{\var{s}.symmetric_difference(\var{t})}
! {new set with elements in either \var{s} or \var{t} but not both}
! \lineii{\var{s}.copy()}
! {new set with a shallow copy of \var{s}}
! \end{tableii}
In addition to the above operations, both \class{Set} and \class{ImmutableSet}
***************
*** 106,149 ****
but not found in \class{Set}:
! \begin{tableiii}{c|l|c}{code}{Operation}{Result}{Notes}
! \lineiii{hash(\var{s})}{returns a hash value for \var{s}}{}
! \end{tableiii}
The following table lists operations available in \class{Set}
but not found in \class{ImmutableSet}:
! \begin{tableiii}{c|l|c}{code}{Operation}{Result}{Notes}
! \lineiii{\var{s} |= \var{t}}
! {return set \var{s} with elements added from \var{t}}{}
! \lineiii{\var{s}.union_update(\var{t})}
! {return set \var{s} with elements added from \var{t}}{}
! \lineiii{\var{s} &= \var{t}}
! {return set \var{s} keeping only elements also found in \var{t}}{}
! \lineiii{\var{s}.intersection_update(\var{t})}
! {return set \var{s} keeping only elements also found in \var{t}}{}
! \lineiii{\var{s} -= \var{t}}
! {return set \var{s} after removing elements found in \var{t}}{}
! \lineiii{\var{s}.difference_update(\var{t})}
! {return set \var{s} after removing elements found in \var{t}}{}
! \lineiii{\var{s} ^= \var{t}}
! {return set \var{s} with elements from \var{s} or \var{t} but not both}{}
! \lineiii{\var{s}.symmetric_difference_update(\var{t})}
! {return set \var{s} with elements from \var{s} or \var{t} but not both}{}
\hline
! \lineiii{\var{s}.add(\var{x})}
! {Add element \var{x} to set \var{s}}{}
! \lineiii{\var{s}.remove(\var{x})}
! {Remove element \var{x} from set \var{s}}{}
! \lineiii{\var{s}.discard(\var{x})}
! {Removes element \var{x} from set \var{s} like \var{s}.remove(\var{x})
! but does not raise a KeyError if \var{x} is not in \var{s}}{}
! \lineiii{\var{s}.pop()}
! {Remove and return a randomly-chosen element from \var{s}}{}
! \lineiii{\var{s}.update(\var{t})}
! {Add elements from \var{t} to set \var{s}}{}
! \lineiii{\var{s}.clear()}
! {Remove all elements from set \var{s}}{}
! \end{tableiii}
--- 108,153 ----
but not found in \class{Set}:
! \begin{tableii}{c|l|c}{code}{Operation}{Result}
! \lineii{hash(\var{s})}{returns a hash value for \var{s}}
! \end{tableii}
The following table lists operations available in \class{Set}
but not found in \class{ImmutableSet}:
! \begin{tableii}{c|l}{code}{Operation}{Result}
! \lineii{\var{s} |= \var{t}}
! {return set \var{s} with elements added from \var{t}}
! \lineii{\var{s}.union_update(\var{t})}
! {return set \var{s} with elements added from \var{t}}
! \lineii{\var{s} \&= \var{t}}
! {return set \var{s} keeping only elements also found in \var{t}}
! \lineii{\var{s}.intersection_update(\var{t})}
! {return set \var{s} keeping only elements also found in \var{t}}
! \lineii{\var{s} -= \var{t}}
! {return set \var{s} after removing elements found in \var{t}}
! \lineii{\var{s}.difference_update(\var{t})}
! {return set \var{s} after removing elements found in \var{t}}
! \lineii{\var{s} \textasciicircum= \var{t}}
! {return set \var{s} with elements from \var{s} or \var{t}
! but not both}
! \lineii{\var{s}.symmetric_difference_update(\var{t})}
! {return set \var{s} with elements from \var{s} or \var{t}
! but not both}
\hline
! \lineii{\var{s}.add(\var{x})}
! {Add element \var{x} to set \var{s}}
! \lineii{\var{s}.remove(\var{x})}
! {Remove element \var{x} from set \var{s}}
! \lineii{\var{s}.discard(\var{x})}
! {Removes element \var{x} from set \var{s} like \var{s}.remove(\var{x})
! but does not raise a KeyError if \var{x} is not in \var{s}}
! \lineii{\var{s}.pop()}
! {Remove and return a randomly-chosen element from \var{s}}
! \lineii{\var{s}.update(\var{t})}
! {Add elements from \var{t} to set \var{s}}
! \lineii{\var{s}.clear()}
! {Remove all elements from set \var{s}}
! \end{tableii}
***************
*** 184,190 ****
before being added as a set element.
! The mechanism is to always add a hashable element, or if it is not hashable,
! the element is checked to see if it has an \method{_as_immutable()} method
! which returns an immutable equivalent.
Since \class{Set} objects have a \method{_as_immutable()} method
--- 188,194 ----
before being added as a set element.
! The mechanism is to always add a hashable element, or if it is not
! hashable, the element is checked to see if it has an
! \method{_as_immutable()} method which returns an immutable equivalent.
Since \class{Set} objects have a \method{_as_immutable()} method
***************
*** 195,199 ****
\method{remove()} methods which need to hash an element to check
for membership in a set. Those methods check an element for hashability
! and, if not, check for a \method{_as_Temporarily_Immutable} method
which returns the element wrapped by a class that provides temporary
methods for \method{__hash__()}, \method{__eq__()}, and \method{__ne__()}.
--- 199,203 ----
\method{remove()} methods which need to hash an element to check
for membership in a set. Those methods check an element for hashability
! and, if not, check for a \method{_as_Temporarily_Immutable()} method
which returns the element wrapped by a class that provides temporary
methods for \method{__hash__()}, \method{__eq__()}, and \method{__ne__()}.
***************
*** 202,207 ****
the original mutable object.
! \class{Set} objects implement the \method{_as_Temporarily_Immutable} method
! which returns the \class{Set} object wrapped by a new class
\class{_TemporarilyImmutableSet}.
--- 206,211 ----
the original mutable object.
! \class{Set} objects implement the \method{_as_Temporarily_Immutable()}
! method which returns the \class{Set} object wrapped by a new class
\class{_TemporarilyImmutableSet}.
***************
*** 211,219 ****
in \class{_TemporarilyImmutableSet}. In other words, sets of mutable sets
are not thread-safe.
-
-
-
-
-
-
-
--- 215,216 ----