Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 1 | \section{\module{sets} --- |
| 2 | Unordered collections of unique elements} |
| 3 | |
| 4 | \declaremodule{standard}{sets} |
| 5 | \modulesynopsis{Implementation of sets of unique elements.} |
| 6 | \moduleauthor{Greg V. Wilson}{gvwilson@nevex.com} |
| 7 | \moduleauthor{Alex Martelli}{aleax@aleax.it} |
| 8 | \moduleauthor{Guido van Rossum}{guido@python.org} |
| 9 | \sectionauthor{Raymond D. Hettinger}{python@rcn.com} |
| 10 | |
| 11 | \versionadded{2.3} |
| 12 | |
| 13 | The \module{sets} module provides classes for constructing and manipulating |
| 14 | unordered collections of unique elements. Common uses include membership |
| 15 | testing, removing duplicates from a sequence, and computing standard math |
| 16 | operations on sets such as intersection, union, difference, and symmetric |
| 17 | difference. |
| 18 | |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 19 | Like other collections, sets support \code{\var{x} in \var{set}}, |
| 20 | \code{len(\var{set})}, and \code{for \var{x} in \var{set}}. Being an |
| 21 | unordered collection, sets do not record element position or order of |
| 22 | insertion. Accordingly, sets do not support indexing, slicing, or |
| 23 | other sequence-like behavior. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 24 | |
| 25 | Most set applications use the \class{Set} class which provides every set |
| 26 | method except for \method{__hash__()}. For advanced applications requiring |
| 27 | a hash method, the \class{ImmutableSet} class adds a \method{__hash__()} |
| 28 | method but omits methods which alter the contents of the set. Both |
| 29 | \class{Set} and \class{ImmutableSet} derive from \class{BaseSet}, an |
| 30 | abstract class useful for determining whether something is a set: |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 31 | \code{isinstance(\var{obj}, BaseSet)}. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 32 | |
Raymond Hettinger | e490502 | 2005-04-10 17:32:35 +0000 | [diff] [blame] | 33 | The set classes are implemented using dictionaries. Accordingly, the |
| 34 | requirements for set elements are the same as those for dictionary keys; |
| 35 | namely, that the element defines both \method{__eq__} and \method{__hash__}. |
| 36 | As a result, sets |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 37 | cannot contain mutable elements such as lists or dictionaries. |
| 38 | However, they can contain immutable collections such as tuples or |
Raymond Hettinger | fa8dd5f | 2002-08-23 18:10:54 +0000 | [diff] [blame] | 39 | instances of \class{ImmutableSet}. For convenience in implementing |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 40 | sets of sets, inner sets are automatically converted to immutable |
| 41 | form, for example, \code{Set([Set(['dog'])])} is transformed to |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 42 | \code{Set([ImmutableSet(['dog'])])}. |
| 43 | |
| 44 | \begin{classdesc}{Set}{\optional{iterable}} |
| 45 | Constructs a new empty \class{Set} object. If the optional \var{iterable} |
| 46 | parameter is supplied, updates the set with elements obtained from iteration. |
| 47 | All of the elements in \var{iterable} should be immutable or be transformable |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 48 | to an immutable using the protocol described in |
| 49 | section~\ref{immutable-transforms}. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 50 | \end{classdesc} |
| 51 | |
| 52 | \begin{classdesc}{ImmutableSet}{\optional{iterable}} |
| 53 | Constructs a new empty \class{ImmutableSet} object. If the optional |
| 54 | \var{iterable} parameter is supplied, updates the set with elements obtained |
| 55 | from iteration. All of the elements in \var{iterable} should be immutable or |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 56 | be transformable to an immutable using the protocol described in |
| 57 | section~\ref{immutable-transforms}. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 58 | |
| 59 | Because \class{ImmutableSet} objects provide a \method{__hash__()} method, |
| 60 | they can be used as set elements or as dictionary keys. \class{ImmutableSet} |
| 61 | objects do not have methods for adding or removing elements, so all of the |
| 62 | elements must be known when the constructor is called. |
| 63 | \end{classdesc} |
| 64 | |
| 65 | |
Fred Drake | 2e3ae21 | 2003-01-06 15:50:32 +0000 | [diff] [blame] | 66 | \subsection{Set Objects \label{set-objects}} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 67 | |
| 68 | Instances of \class{Set} and \class{ImmutableSet} both provide |
| 69 | the following operations: |
| 70 | |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 71 | \begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result} |
| 72 | \lineiii{len(\var{s})}{}{cardinality of set \var{s}} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 73 | |
| 74 | \hline |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 75 | \lineiii{\var{x} in \var{s}}{} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 76 | {test \var{x} for membership in \var{s}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 77 | \lineiii{\var{x} not in \var{s}}{} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 78 | {test \var{x} for non-membership in \var{s}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 79 | \lineiii{\var{s}.issubset(\var{t})}{\code{\var{s} <= \var{t}}} |
| 80 | {test whether every element in \var{s} is in \var{t}} |
| 81 | \lineiii{\var{s}.issuperset(\var{t})}{\code{\var{s} >= \var{t}}} |
| 82 | {test whether every element in \var{t} is in \var{s}} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 83 | |
| 84 | \hline |
Fred Drake | 447083e | 2005-01-19 07:24:34 +0000 | [diff] [blame] | 85 | \lineiii{\var{s}.union(\var{t})}{\var{s} \textbar{} \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 86 | {new set with elements from both \var{s} and \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 87 | \lineiii{\var{s}.intersection(\var{t})}{\var{s} \&\ \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 88 | {new set with elements common to \var{s} and \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 89 | \lineiii{\var{s}.difference(\var{t})}{\var{s} - \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 90 | {new set with elements in \var{s} but not in \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 91 | \lineiii{\var{s}.symmetric_difference(\var{t})}{\var{s} \^\ \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 92 | {new set with elements in either \var{s} or \var{t} but not both} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 93 | \lineiii{\var{s}.copy()}{} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 94 | {new set with a shallow copy of \var{s}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 95 | \end{tableiii} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 96 | |
Raymond Hettinger | d446230 | 2003-11-26 17:52:45 +0000 | [diff] [blame] | 97 | Note, the non-operator versions of \method{union()}, |
Raymond Hettinger | 6a18012 | 2003-08-17 08:34:09 +0000 | [diff] [blame] | 98 | \method{intersection()}, \method{difference()}, and |
| 99 | \method{symmetric_difference()} will accept any iterable as an argument. |
| 100 | In contrast, their operator based counterparts require their arguments to |
| 101 | be sets. This precludes error-prone constructions like |
| 102 | \code{Set('abc') \&\ 'cbs'} in favor of the more readable |
| 103 | \code{Set('abc').intersection('cbs')}. |
| 104 | \versionchanged[Formerly all arguments were required to be sets]{2.3.1} |
| 105 | |
Tim Peters | ea76c98 | 2002-08-25 18:43:10 +0000 | [diff] [blame] | 106 | In addition, both \class{Set} and \class{ImmutableSet} |
| 107 | support set to set comparisons. Two sets are equal if and only if |
| 108 | every element of each set is contained in the other (each is a subset |
| 109 | of the other). |
| 110 | A set is less than another set if and only if the first set is a proper |
| 111 | subset of the second set (is a subset, but is not equal). |
| 112 | A set is greater than another set if and only if the first set is a proper |
| 113 | superset of the second set (is a superset, but is not equal). |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 114 | |
Raymond Hettinger | 3801ec7 | 2003-01-15 15:46:05 +0000 | [diff] [blame] | 115 | The subset and equality comparisons do not generalize to a complete |
| 116 | ordering function. For example, any two disjoint sets are not equal and |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 117 | are not subsets of each other, so \emph{all} of the following return |
| 118 | \code{False}: \code{\var{a}<\var{b}}, \code{\var{a}==\var{b}}, or |
| 119 | \code{\var{a}>\var{b}}. |
Raymond Hettinger | 3801ec7 | 2003-01-15 15:46:05 +0000 | [diff] [blame] | 120 | Accordingly, sets do not implement the \method{__cmp__} method. |
| 121 | |
| 122 | Since sets only define partial ordering (subset relationships), the output |
| 123 | of the \method{list.sort()} method is undefined for lists of sets. |
| 124 | |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 125 | The following table lists operations available in \class{ImmutableSet} |
| 126 | but not found in \class{Set}: |
| 127 | |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 128 | \begin{tableii}{c|l}{code}{Operation}{Result} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 129 | \lineii{hash(\var{s})}{returns a hash value for \var{s}} |
| 130 | \end{tableii} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 131 | |
| 132 | The following table lists operations available in \class{Set} |
| 133 | but not found in \class{ImmutableSet}: |
| 134 | |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 135 | \begin{tableiii}{c|c|l}{code}{Operation}{Equivalent}{Result} |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 136 | \lineiii{\var{s}.update(\var{t})} |
Fred Drake | 447083e | 2005-01-19 07:24:34 +0000 | [diff] [blame] | 137 | {\var{s} \textbar= \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 138 | {return set \var{s} with elements added from \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 139 | \lineiii{\var{s}.intersection_update(\var{t})} |
| 140 | {\var{s} \&= \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 141 | {return set \var{s} keeping only elements also found in \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 142 | \lineiii{\var{s}.difference_update(\var{t})} |
| 143 | {\var{s} -= \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 144 | {return set \var{s} after removing elements found in \var{t}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 145 | \lineiii{\var{s}.symmetric_difference_update(\var{t})} |
| 146 | {\var{s} \textasciicircum= \var{t}} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 147 | {return set \var{s} with elements from \var{s} or \var{t} |
| 148 | but not both} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 149 | |
| 150 | \hline |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 151 | \lineiii{\var{s}.add(\var{x})}{} |
Fred Drake | 2e3ae21 | 2003-01-06 15:50:32 +0000 | [diff] [blame] | 152 | {add element \var{x} to set \var{s}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 153 | \lineiii{\var{s}.remove(\var{x})}{} |
| 154 | {remove \var{x} from set \var{s}; raises KeyError if not present} |
| 155 | \lineiii{\var{s}.discard(\var{x})}{} |
Fred Drake | 2e3ae21 | 2003-01-06 15:50:32 +0000 | [diff] [blame] | 156 | {removes \var{x} from set \var{s} if present} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 157 | \lineiii{\var{s}.pop()}{} |
| 158 | {remove and return an arbitrary element from \var{s}; raises |
| 159 | KeyError if empty} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 160 | \lineiii{\var{s}.clear()}{} |
Fred Drake | 2e3ae21 | 2003-01-06 15:50:32 +0000 | [diff] [blame] | 161 | {remove all elements from set \var{s}} |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 162 | \end{tableiii} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 163 | |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 164 | Note, the non-operator versions of \method{update()}, |
Raymond Hettinger | 6a18012 | 2003-08-17 08:34:09 +0000 | [diff] [blame] | 165 | \method{intersection_update()}, \method{difference_update()}, and |
| 166 | \method{symmetric_difference_update()} will accept any iterable as |
| 167 | an argument. |
| 168 | \versionchanged[Formerly all arguments were required to be sets]{2.3.1} |
| 169 | |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 170 | Also note, the module also includes a \method{union_update()} method |
| 171 | which is an alias for \method{update()}. The method is included for |
Georg Brandl | 08c02db | 2005-07-22 18:39:19 +0000 | [diff] [blame] | 172 | backwards compatibility. Programmers should prefer the |
Neal Norwitz | 26f4c23 | 2005-11-03 04:39:09 +0000 | [diff] [blame] | 173 | \method{update()} method because it is supported by the builtin |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 174 | \class{set()} and \class{frozenset()} types. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 175 | |
Fred Drake | 2e3ae21 | 2003-01-06 15:50:32 +0000 | [diff] [blame] | 176 | \subsection{Example \label{set-example}} |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 177 | |
| 178 | \begin{verbatim} |
| 179 | >>> from sets import Set |
| 180 | >>> engineers = Set(['John', 'Jane', 'Jack', 'Janice']) |
| 181 | >>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice']) |
Raymond Hettinger | 7ceb29e | 2003-08-16 00:56:40 +0000 | [diff] [blame] | 182 | >>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack']) |
| 183 | >>> employees = engineers | programmers | managers # union |
| 184 | >>> engineering_management = engineers & managers # intersection |
| 185 | >>> fulltime_management = managers - engineers - programmers # difference |
| 186 | >>> engineers.add('Marvin') # add element |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 187 | >>> print engineers |
| 188 | Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack']) |
| 189 | >>> employees.issuperset(engineers) # superset test |
| 190 | False |
Raymond Hettinger | 6a18012 | 2003-08-17 08:34:09 +0000 | [diff] [blame] | 191 | >>> employees.union_update(engineers) # update from another set |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 192 | >>> employees.issuperset(engineers) |
| 193 | True |
Raymond Hettinger | d456849 | 2003-11-16 13:44:19 +0000 | [diff] [blame] | 194 | >>> for group in [engineers, programmers, managers, employees]: |
Raymond Hettinger | 3801ec7 | 2003-01-15 15:46:05 +0000 | [diff] [blame] | 195 | ... group.discard('Susan') # unconditionally remove element |
| 196 | ... print group |
| 197 | ... |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 198 | Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack']) |
| 199 | Set(['Janice', 'Jack', 'Sam']) |
| 200 | Set(['Jane', 'Zack', 'Jack']) |
| 201 | Set(['Jack', 'Sam', 'Jane', 'Marvin', 'Janice', 'John', 'Zack']) |
| 202 | \end{verbatim} |
| 203 | |
| 204 | |
| 205 | \subsection{Protocol for automatic conversion to immutable |
| 206 | \label{immutable-transforms}} |
| 207 | |
| 208 | Sets can only contain immutable elements. For convenience, mutable |
| 209 | \class{Set} objects are automatically copied to an \class{ImmutableSet} |
| 210 | before being added as a set element. |
| 211 | |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 212 | The mechanism is to always add a hashable element, or if it is not |
| 213 | hashable, the element is checked to see if it has an |
Raymond Hettinger | 2835e37 | 2003-02-14 03:42:11 +0000 | [diff] [blame] | 214 | \method{__as_immutable__()} method which returns an immutable equivalent. |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 215 | |
Raymond Hettinger | 2835e37 | 2003-02-14 03:42:11 +0000 | [diff] [blame] | 216 | Since \class{Set} objects have a \method{__as_immutable__()} method |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 217 | returning an instance of \class{ImmutableSet}, it is possible to |
| 218 | construct sets of sets. |
| 219 | |
| 220 | A similar mechanism is needed by the \method{__contains__()} and |
| 221 | \method{remove()} methods which need to hash an element to check |
| 222 | for membership in a set. Those methods check an element for hashability |
Raymond Hettinger | 2835e37 | 2003-02-14 03:42:11 +0000 | [diff] [blame] | 223 | and, if not, check for a \method{__as_temporarily_immutable__()} method |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 224 | which returns the element wrapped by a class that provides temporary |
| 225 | methods for \method{__hash__()}, \method{__eq__()}, and \method{__ne__()}. |
| 226 | |
| 227 | The alternate mechanism spares the need to build a separate copy of |
| 228 | the original mutable object. |
| 229 | |
Raymond Hettinger | 2835e37 | 2003-02-14 03:42:11 +0000 | [diff] [blame] | 230 | \class{Set} objects implement the \method{__as_temporarily_immutable__()} |
Fred Drake | d10c6c9 | 2002-08-23 17:22:36 +0000 | [diff] [blame] | 231 | method which returns the \class{Set} object wrapped by a new class |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 232 | \class{_TemporarilyImmutableSet}. |
| 233 | |
| 234 | The two mechanisms for adding hashability are normally invisible to the |
| 235 | user; however, a conflict can arise in a multi-threaded environment |
Raymond Hettinger | fa8dd5f | 2002-08-23 18:10:54 +0000 | [diff] [blame] | 236 | where one thread is updating a set while another has temporarily wrapped it |
Raymond Hettinger | 584cb19 | 2002-08-23 15:18:38 +0000 | [diff] [blame] | 237 | in \class{_TemporarilyImmutableSet}. In other words, sets of mutable sets |
| 238 | are not thread-safe. |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 239 | |
| 240 | |
| 241 | \subsection{Comparison to the built-in \class{set} types |
| 242 | \label{comparison-to-builtin-set}} |
| 243 | |
| 244 | The built-in \class{set} and \class{frozenset} types were designed based |
| 245 | on lessons learned from the \module{sets} module. The key differences are: |
| 246 | |
| 247 | \begin{itemize} |
| 248 | \item \class{Set} and \class{ImmutableSet} were renamed to \class{set} and |
| 249 | \class{frozenset}. |
| 250 | \item There is no equivalent to \class{BaseSet}. Instead, use |
| 251 | \code{isinstance(x, (set, frozenset))}. |
| 252 | \item The hash algorithm for the built-ins performs significantly better |
| 253 | (fewer collisions) for most datasets. |
| 254 | \item The built-in versions have more space efficient pickles. |
| 255 | \item The built-in versions do not have a \method{union_update()} method. |
| 256 | Instead, use the \method{update()} method which is equivalent. |
Georg Brandl | 08c02db | 2005-07-22 18:39:19 +0000 | [diff] [blame] | 257 | \item The built-in versions do not have a \method{_repr(sorted=True)} method. |
Raymond Hettinger | 16ffbc3 | 2005-07-01 23:00:13 +0000 | [diff] [blame] | 258 | Instead, use the built-in \function{repr()} and \function{sorted()} |
| 259 | functions: \code{repr(sorted(s))}. |
| 260 | \item The built-in version does not have a protocol for automatic conversion |
| 261 | to immutable. Many found this feature to be confusing and no one |
| 262 | in the community reported having found real uses for it. |
| 263 | \end{itemize} |