blob: 32a0dd64ff871dc15ef658b699096931c7afa405 [file] [log] [blame]
Guido van Rossumd6cf3af2002-08-19 16:19:15 +00001"""Classes to represent arbitrary sets (including sets of sets).
2
3This module implements sets using dictionaries whose values are
4ignored. The usual operations (union, intersection, deletion, etc.)
5are provided as both methods and operators.
6
Guido van Rossum290f1872002-08-20 20:05:23 +00007Important: sets are not sequences! While they support 'x in s',
8'len(s)', and 'for x in s', none of those operations are unique for
9sequences; for example, mappings support all three as well. The
10characteristic operation for sequences is subscripting with small
11integers: s[i], for i in range(len(s)). Sets don't support
12subscripting at all. Also, sequences allow multiple occurrences and
13their elements have a definite order; sets on the other hand don't
14record multiple occurrences and don't remember the order of element
15insertion (which is why they don't support s[i]).
16
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000017The following classes are provided:
18
19BaseSet -- All the operations common to both mutable and immutable
20 sets. This is an abstract class, not meant to be directly
21 instantiated.
22
23Set -- Mutable sets, subclass of BaseSet; not hashable.
24
25ImmutableSet -- Immutable sets, subclass of BaseSet; hashable.
26 An iterable argument is mandatory to create an ImmutableSet.
27
Raymond Hettingerf6fe4ed2003-06-26 18:49:28 +000028_TemporarilyImmutableSet -- A wrapper around a Set, hashable,
29 giving the same hash value as the immutable set equivalent
30 would have. Do not use this class directly.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000031
32Only hashable objects can be added to a Set. In particular, you cannot
33really add a Set as an element to another Set; if you try, what is
Raymond Hettingerede3a0d2002-08-20 23:34:01 +000034actually added is an ImmutableSet built from it (it compares equal to
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000035the one you tried adding).
36
37When you ask if `x in y' where x is a Set and y is a Set or
38ImmutableSet, x is wrapped into a _TemporarilyImmutableSet z, and
39what's tested is actually `z in y'.
40
41"""
42
43# Code history:
44#
45# - Greg V. Wilson wrote the first version, using a different approach
46# to the mutable/immutable problem, and inheriting from dict.
47#
48# - Alex Martelli modified Greg's version to implement the current
49# Set/ImmutableSet approach, and make the data an attribute.
50#
51# - Guido van Rossum rewrote much of the code, made some API changes,
52# and cleaned up the docstrings.
Guido van Rossum26588222002-08-21 02:44:04 +000053#
Guido van Rossum9f872932002-08-21 03:20:44 +000054# - Raymond Hettinger added a number of speedups and other
Guido van Rossumdc61cdf2002-08-22 17:23:33 +000055# improvements.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000056
Raymond Hettingeree562fc2003-08-15 21:17:04 +000057from __future__ import generators
58try:
59 from itertools import ifilter, ifilterfalse
60except ImportError:
61 # Code to make the module run under Py2.2
62 def ifilter(predicate, iterable):
63 if predicate is None:
64 def predicate(x):
65 return x
66 for x in iterable:
67 if predicate(x):
68 yield x
69 def ifilterfalse(predicate, iterable):
70 if predicate is None:
71 def predicate(x):
72 return x
73 for x in iterable:
74 if not predicate(x):
75 yield x
Raymond Hettinger859db262003-11-12 15:21:20 +000076 try:
77 True, False
78 except NameError:
79 True, False = (0==0, 0!=0)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000080
81__all__ = ['BaseSet', 'Set', 'ImmutableSet']
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000082
83class BaseSet(object):
84 """Common base class for mutable and immutable sets."""
85
86 __slots__ = ['_data']
87
88 # Constructor
89
Guido van Rossum5033b362002-08-20 21:38:37 +000090 def __init__(self):
91 """This is an abstract class."""
92 # Don't call this from a concrete subclass!
93 if self.__class__ is BaseSet:
Guido van Rossum9f872932002-08-21 03:20:44 +000094 raise TypeError, ("BaseSet is an abstract class. "
95 "Use Set or ImmutableSet.")
Guido van Rossumd6cf3af2002-08-19 16:19:15 +000096
97 # Standard protocols: __len__, __repr__, __str__, __iter__
98
99 def __len__(self):
100 """Return the number of elements of a set."""
101 return len(self._data)
102
103 def __repr__(self):
104 """Return string representation of a set.
105
106 This looks like 'Set([<list of elements>])'.
107 """
108 return self._repr()
109
110 # __str__ is the same as __repr__
111 __str__ = __repr__
112
113 def _repr(self, sorted=False):
114 elements = self._data.keys()
115 if sorted:
116 elements.sort()
117 return '%s(%r)' % (self.__class__.__name__, elements)
118
119 def __iter__(self):
120 """Return an iterator over the elements or a set.
121
122 This is the keys iterator for the underlying dict.
123 """
124 return self._data.iterkeys()
125
Tim Peters44f14b02003-03-02 00:19:49 +0000126 # Three-way comparison is not supported. However, because __eq__ is
127 # tried before __cmp__, if Set x == Set y, x.__eq__(y) returns True and
128 # then cmp(x, y) returns 0 (Python doesn't actually call __cmp__ in this
129 # case).
Guido van Rossum50e92232003-01-14 16:45:04 +0000130
131 def __cmp__(self, other):
132 raise TypeError, "can't compare sets using cmp()"
133
Tim Peters44f14b02003-03-02 00:19:49 +0000134 # Equality comparisons using the underlying dicts. Mixed-type comparisons
135 # are allowed here, where Set == z for non-Set z always returns False,
136 # and Set != z always True. This allows expressions like "x in y" to
137 # give the expected result when y is a sequence of mixed types, not
138 # raising a pointless TypeError just because y contains a Set, or x is
139 # a Set and y contain's a non-set ("in" invokes only __eq__).
140 # Subtle: it would be nicer if __eq__ and __ne__ could return
141 # NotImplemented instead of True or False. Then the other comparand
142 # would get a chance to determine the result, and if the other comparand
143 # also returned NotImplemented then it would fall back to object address
144 # comparison (which would always return False for __eq__ and always
145 # True for __ne__). However, that doesn't work, because this type
146 # *also* implements __cmp__: if, e.g., __eq__ returns NotImplemented,
147 # Python tries __cmp__ next, and the __cmp__ here then raises TypeError.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000148
149 def __eq__(self, other):
Tim Peters44f14b02003-03-02 00:19:49 +0000150 if isinstance(other, BaseSet):
151 return self._data == other._data
152 else:
153 return False
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000154
155 def __ne__(self, other):
Tim Peters44f14b02003-03-02 00:19:49 +0000156 if isinstance(other, BaseSet):
157 return self._data != other._data
158 else:
159 return True
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000160
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000161 # Copying operations
162
163 def copy(self):
164 """Return a shallow copy of a set."""
Raymond Hettingerfa1480f2002-08-24 02:35:48 +0000165 result = self.__class__()
Raymond Hettingerd9c91512002-08-21 13:20:51 +0000166 result._data.update(self._data)
167 return result
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000168
169 __copy__ = copy # For the copy module
170
171 def __deepcopy__(self, memo):
172 """Return a deep copy of a set; used by copy module."""
173 # This pre-creates the result and inserts it in the memo
174 # early, in case the deep copy recurses into another reference
175 # to this same set. A set can't be an element of itself, but
176 # it can certainly contain an object that has a reference to
177 # itself.
178 from copy import deepcopy
Raymond Hettingerfa1480f2002-08-24 02:35:48 +0000179 result = self.__class__()
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000180 memo[id(self)] = result
181 data = result._data
182 value = True
183 for elt in self:
184 data[deepcopy(elt, memo)] = value
185 return result
186
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000187 # Standard set operations: union, intersection, both differences.
188 # Each has an operator version (e.g. __or__, invoked with |) and a
189 # method version (e.g. union).
Tim Peters4924db12002-08-25 17:10:17 +0000190 # Subtle: Each pair requires distinct code so that the outcome is
191 # correct when the type of other isn't suitable. For example, if
192 # we did "union = __or__" instead, then Set().union(3) would return
193 # NotImplemented instead of raising TypeError (albeit that *why* it
194 # raises TypeError as-is is also a bit subtle).
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000195
196 def __or__(self, other):
197 """Return the union of two sets as a new set.
198
199 (I.e. all elements that are in either set.)
200 """
201 if not isinstance(other, BaseSet):
202 return NotImplemented
Raymond Hettinger6a180122003-08-17 08:34:09 +0000203 return self.union(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000204
205 def union(self, other):
206 """Return the union of two sets as a new set.
207
208 (I.e. all elements that are in either set.)
209 """
Raymond Hettinger6a180122003-08-17 08:34:09 +0000210 result = self.__class__(self)
211 result._update(other)
212 return result
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000213
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000214 def __and__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000215 """Return the intersection of two sets as a new set.
216
217 (I.e. all elements that are in both sets.)
218 """
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000219 if not isinstance(other, BaseSet):
220 return NotImplemented
Raymond Hettinger6a180122003-08-17 08:34:09 +0000221 return self.intersection(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000222
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000223 def intersection(self, other):
224 """Return the intersection of two sets as a new set.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000225
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000226 (I.e. all elements that are in both sets.)
227 """
Raymond Hettinger6a180122003-08-17 08:34:09 +0000228 if not isinstance(other, BaseSet):
229 other = Set(other)
230 if len(self) <= len(other):
231 little, big = self, other
232 else:
233 little, big = other, self
234 common = ifilter(big._data.has_key, little)
235 return self.__class__(common)
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000236
237 def __xor__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000238 """Return the symmetric difference of two sets as a new set.
239
240 (I.e. all elements that are in exactly one of the sets.)
241 """
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000242 if not isinstance(other, BaseSet):
243 return NotImplemented
Raymond Hettinger6a180122003-08-17 08:34:09 +0000244 return self.symmetric_difference(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000245
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000246 def symmetric_difference(self, other):
247 """Return the symmetric difference of two sets as a new set.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000248
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000249 (I.e. all elements that are in exactly one of the sets.)
250 """
Raymond Hettinger6a180122003-08-17 08:34:09 +0000251 result = self.__class__()
252 data = result._data
253 value = True
254 selfdata = self._data
255 try:
256 otherdata = other._data
257 except AttributeError:
258 otherdata = Set(other)._data
259 for elt in ifilterfalse(otherdata.has_key, selfdata):
260 data[elt] = value
261 for elt in ifilterfalse(selfdata.has_key, otherdata):
262 data[elt] = value
263 return result
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000264
265 def __sub__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000266 """Return the difference of two sets as a new Set.
267
268 (I.e. all elements that are in this set and not in the other.)
269 """
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000270 if not isinstance(other, BaseSet):
271 return NotImplemented
Raymond Hettinger6a180122003-08-17 08:34:09 +0000272 return self.difference(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000273
Guido van Rossumdc61cdf2002-08-22 17:23:33 +0000274 def difference(self, other):
275 """Return the difference of two sets as a new Set.
276
277 (I.e. all elements that are in this set and not in the other.)
278 """
Raymond Hettinger6a180122003-08-17 08:34:09 +0000279 result = self.__class__()
280 data = result._data
281 try:
282 otherdata = other._data
283 except AttributeError:
284 otherdata = Set(other)._data
285 value = True
286 for elt in ifilterfalse(otherdata.has_key, self):
287 data[elt] = value
288 return result
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000289
290 # Membership test
291
292 def __contains__(self, element):
293 """Report whether an element is a member of a set.
294
295 (Called in response to the expression `element in self'.)
296 """
297 try:
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000298 return element in self._data
299 except TypeError:
Raymond Hettinger2835e372003-02-14 03:42:11 +0000300 transform = getattr(element, "__as_temporarily_immutable__", None)
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000301 if transform is None:
302 raise # re-raise the TypeError exception we caught
303 return transform() in self._data
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000304
305 # Subset and superset test
306
307 def issubset(self, other):
308 """Report whether another set contains this set."""
309 self._binary_sanity_check(other)
Raymond Hettinger43db0d62002-08-21 02:22:08 +0000310 if len(self) > len(other): # Fast check for obvious cases
311 return False
Raymond Hettinger60eca932003-02-09 06:40:58 +0000312 for elt in ifilterfalse(other._data.has_key, self):
Raymond Hettingera3a53182003-02-02 14:27:19 +0000313 return False
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000314 return True
315
316 def issuperset(self, other):
317 """Report whether this set contains another set."""
318 self._binary_sanity_check(other)
Raymond Hettinger43db0d62002-08-21 02:22:08 +0000319 if len(self) < len(other): # Fast check for obvious cases
320 return False
Raymond Hettinger60eca932003-02-09 06:40:58 +0000321 for elt in ifilterfalse(self._data.has_key, other):
Tim Peters322d5532003-02-04 00:38:20 +0000322 return False
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000323 return True
324
Tim Petersea76c982002-08-25 18:43:10 +0000325 # Inequality comparisons using the is-subset relation.
326 __le__ = issubset
327 __ge__ = issuperset
328
329 def __lt__(self, other):
330 self._binary_sanity_check(other)
331 return len(self) < len(other) and self.issubset(other)
332
333 def __gt__(self, other):
334 self._binary_sanity_check(other)
335 return len(self) > len(other) and self.issuperset(other)
336
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000337 # Assorted helpers
338
339 def _binary_sanity_check(self, other):
340 # Check that the other argument to a binary operation is also
341 # a set, raising a TypeError otherwise.
342 if not isinstance(other, BaseSet):
343 raise TypeError, "Binary operation only permitted between sets"
344
345 def _compute_hash(self):
346 # Calculate hash code for a set by xor'ing the hash codes of
Tim Petersd06d0302002-08-23 20:06:42 +0000347 # the elements. This ensures that the hash code does not depend
348 # on the order in which elements are added to the set. This is
349 # not called __hash__ because a BaseSet should not be hashable;
350 # only an ImmutableSet is hashable.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000351 result = 0
352 for elt in self:
353 result ^= hash(elt)
354 return result
355
Guido van Rossum9f872932002-08-21 03:20:44 +0000356 def _update(self, iterable):
357 # The main loop for update() and the subclass __init__() methods.
Guido van Rossum9f872932002-08-21 03:20:44 +0000358 data = self._data
Raymond Hettinger1a8d1932002-08-29 15:13:50 +0000359
360 # Use the fast update() method when a dictionary is available.
361 if isinstance(iterable, BaseSet):
362 data.update(iterable._data)
363 return
Raymond Hettinger1a8d1932002-08-29 15:13:50 +0000364
Tim Peters0ec1ddc2002-11-08 05:26:52 +0000365 value = True
Guido van Rossum7cd83ca2002-11-08 17:03:36 +0000366
367 if type(iterable) in (list, tuple, xrange):
368 # Optimized: we know that __iter__() and next() can't
369 # raise TypeError, so we can move 'try:' out of the loop.
370 it = iter(iterable)
371 while True:
372 try:
373 for element in it:
374 data[element] = value
375 return
376 except TypeError:
Raymond Hettinger2835e372003-02-14 03:42:11 +0000377 transform = getattr(element, "__as_immutable__", None)
Guido van Rossum7cd83ca2002-11-08 17:03:36 +0000378 if transform is None:
379 raise # re-raise the TypeError exception we caught
380 data[transform()] = value
381 else:
382 # Safe: only catch TypeError where intended
383 for element in iterable:
384 try:
Raymond Hettinger80d21af2002-08-21 04:12:03 +0000385 data[element] = value
Guido van Rossum7cd83ca2002-11-08 17:03:36 +0000386 except TypeError:
Raymond Hettinger2835e372003-02-14 03:42:11 +0000387 transform = getattr(element, "__as_immutable__", None)
Guido van Rossum7cd83ca2002-11-08 17:03:36 +0000388 if transform is None:
389 raise # re-raise the TypeError exception we caught
390 data[transform()] = value
Guido van Rossum9f872932002-08-21 03:20:44 +0000391
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000392
393class ImmutableSet(BaseSet):
394 """Immutable set class."""
395
Guido van Rossum0b650d72002-08-19 16:29:58 +0000396 __slots__ = ['_hashcode']
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000397
398 # BaseSet + hashing
399
Guido van Rossum9f872932002-08-21 03:20:44 +0000400 def __init__(self, iterable=None):
401 """Construct an immutable set from an optional iterable."""
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000402 self._hashcode = None
Guido van Rossum9f872932002-08-21 03:20:44 +0000403 self._data = {}
404 if iterable is not None:
405 self._update(iterable)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000406
407 def __hash__(self):
408 if self._hashcode is None:
409 self._hashcode = self._compute_hash()
410 return self._hashcode
411
Jeremy Hyltoncd58b8f2002-11-13 19:34:26 +0000412 def __getstate__(self):
413 return self._data, self._hashcode
414
415 def __setstate__(self, state):
416 self._data, self._hashcode = state
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000417
418class Set(BaseSet):
419 """ Mutable set class."""
420
421 __slots__ = []
422
423 # BaseSet + operations requiring mutability; no hashing
424
Guido van Rossum9f872932002-08-21 03:20:44 +0000425 def __init__(self, iterable=None):
426 """Construct a set from an optional iterable."""
427 self._data = {}
428 if iterable is not None:
429 self._update(iterable)
430
Jeremy Hyltoncd58b8f2002-11-13 19:34:26 +0000431 def __getstate__(self):
432 # getstate's results are ignored if it is not
433 return self._data,
434
435 def __setstate__(self, data):
436 self._data, = data
437
Guido van Rossum9f872932002-08-21 03:20:44 +0000438 def __hash__(self):
439 """A Set cannot be hashed."""
440 # We inherit object.__hash__, so we must deny this explicitly
441 raise TypeError, "Can't hash a Set, only an ImmutableSet."
Guido van Rossum5033b362002-08-20 21:38:37 +0000442
Tim Peters4a2f91e2002-08-25 18:59:04 +0000443 # In-place union, intersection, differences.
444 # Subtle: The xyz_update() functions deliberately return None,
445 # as do all mutating operations on built-in container types.
446 # The __xyz__ spellings have to return self, though.
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000447
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000448 def __ior__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000449 """Update a set with the union of itself and another."""
450 self._binary_sanity_check(other)
451 self._data.update(other._data)
452 return self
453
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000454 def union_update(self, other):
455 """Update a set with the union of itself and another."""
Raymond Hettinger6a180122003-08-17 08:34:09 +0000456 self._update(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000457
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000458 def __iand__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000459 """Update a set with the intersection of itself and another."""
460 self._binary_sanity_check(other)
Tim Peters454602f2002-08-26 00:44:07 +0000461 self._data = (self & other)._data
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000462 return self
463
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000464 def intersection_update(self, other):
465 """Update a set with the intersection of itself and another."""
Raymond Hettinger6a180122003-08-17 08:34:09 +0000466 if isinstance(other, BaseSet):
467 self &= other
468 else:
469 self._data = (self.intersection(other))._data
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000470
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000471 def __ixor__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000472 """Update a set with the symmetric difference of itself and another."""
473 self._binary_sanity_check(other)
Raymond Hettinger6a180122003-08-17 08:34:09 +0000474 self.symmetric_difference_update(other)
475 return self
476
477 def symmetric_difference_update(self, other):
478 """Update a set with the symmetric difference of itself and another."""
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000479 data = self._data
480 value = True
Raymond Hettinger6a180122003-08-17 08:34:09 +0000481 if not isinstance(other, BaseSet):
482 other = Set(other)
Raymond Hettinger038ca2a2005-08-13 02:29:58 +0000483 if self is other:
484 self.clear()
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000485 for elt in other:
486 if elt in data:
487 del data[elt]
488 else:
489 data[elt] = value
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000490
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000491 def __isub__(self, other):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000492 """Remove all elements of another set from this set."""
493 self._binary_sanity_check(other)
Raymond Hettinger6a180122003-08-17 08:34:09 +0000494 self.difference_update(other)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000495 return self
496
Raymond Hettinger1b9f5d42002-08-24 06:19:02 +0000497 def difference_update(self, other):
498 """Remove all elements of another set from this set."""
Raymond Hettinger6a180122003-08-17 08:34:09 +0000499 data = self._data
500 if not isinstance(other, BaseSet):
501 other = Set(other)
Raymond Hettinger038ca2a2005-08-13 02:29:58 +0000502 if self is other:
503 self.clear()
Raymond Hettinger6a180122003-08-17 08:34:09 +0000504 for elt in ifilter(data.has_key, other):
505 del data[elt]
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000506
507 # Python dict-like mass mutations: update, clear
508
509 def update(self, iterable):
510 """Add all values from an iterable (such as a list or file)."""
Guido van Rossum9f872932002-08-21 03:20:44 +0000511 self._update(iterable)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000512
513 def clear(self):
514 """Remove all elements from this set."""
515 self._data.clear()
516
517 # Single-element mutations: add, remove, discard
518
519 def add(self, element):
520 """Add an element to a set.
521
522 This has no effect if the element is already present.
523 """
524 try:
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000525 self._data[element] = True
526 except TypeError:
Raymond Hettinger2835e372003-02-14 03:42:11 +0000527 transform = getattr(element, "__as_immutable__", None)
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000528 if transform is None:
529 raise # re-raise the TypeError exception we caught
530 self._data[transform()] = True
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000531
532 def remove(self, element):
533 """Remove an element from a set; it must be a member.
534
535 If the element is not a member, raise a KeyError.
536 """
537 try:
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000538 del self._data[element]
539 except TypeError:
Raymond Hettinger2835e372003-02-14 03:42:11 +0000540 transform = getattr(element, "__as_temporarily_immutable__", None)
Raymond Hettingerde6d6972002-08-21 01:35:29 +0000541 if transform is None:
542 raise # re-raise the TypeError exception we caught
543 del self._data[transform()]
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000544
545 def discard(self, element):
546 """Remove an element from a set if it is a member.
547
548 If the element is not a member, do nothing.
549 """
550 try:
Guido van Rossume399d082002-08-23 14:45:02 +0000551 self.remove(element)
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000552 except KeyError:
553 pass
554
Guido van Rossumc9196bc2002-08-20 21:51:59 +0000555 def pop(self):
Tim Peters53506be2002-08-23 20:36:58 +0000556 """Remove and return an arbitrary set element."""
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000557 return self._data.popitem()[0]
558
Raymond Hettinger2835e372003-02-14 03:42:11 +0000559 def __as_immutable__(self):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000560 # Return a copy of self as an immutable set
561 return ImmutableSet(self)
562
Raymond Hettinger2835e372003-02-14 03:42:11 +0000563 def __as_temporarily_immutable__(self):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000564 # Return self wrapped in a temporarily immutable set
565 return _TemporarilyImmutableSet(self)
566
567
Raymond Hettingerfa1480f2002-08-24 02:35:48 +0000568class _TemporarilyImmutableSet(BaseSet):
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000569 # Wrap a mutable set as if it was temporarily immutable.
570 # This only supplies hashing and equality comparisons.
571
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000572 def __init__(self, set):
573 self._set = set
Raymond Hettingerfa1480f2002-08-24 02:35:48 +0000574 self._data = set._data # Needed by ImmutableSet.__eq__()
Guido van Rossumd6cf3af2002-08-19 16:19:15 +0000575
576 def __hash__(self):
Raymond Hettingerd5018512002-08-24 04:47:42 +0000577 return self._set._compute_hash()