Back to index

python3.2  3.2.2
Public Member Functions | Private Member Functions
_abcoll.Set Class Reference
Inheritance diagram for _abcoll.Set:
Inheritance graph
[legend]
Collaboration diagram for _abcoll.Set:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __le__
def __lt__
def __gt__
def __ge__
def __eq__
def __ne__
def __and__
def isdisjoint
def __or__
def __sub__
def __xor__
def __len__
def __subclasshook__
def __new__
def register
def __instancecheck__
def __subclasscheck__
def __iter__
def __subclasshook__
def __new__
def register
def __instancecheck__
def __subclasscheck__
def __contains__
def __subclasshook__
def __new__
def register
def __instancecheck__
def __subclasscheck__

Private Member Functions

def _from_iterable
def _hash

Detailed Description

A set is a finite, iterable container.

This class provides concrete generic implementations of all
methods except for __contains__, __iter__ and __len__.

To override the comparisons (presumably for speed, as the
semantics are fixed), all you have to do is redefine __le__ and
then the other operations will automatically follow suit.

Definition at line 157 of file _abcoll.py.


Member Function Documentation

def _abcoll.Set.__and__ (   self,
  other 
)

Definition at line 211 of file _abcoll.py.

00211 
00212     def __and__(self, other):
00213         if not isinstance(other, Iterable):
00214             return NotImplemented
00215         return self._from_iterable(value for value in other if value in self)

Here is the call graph for this function:

def _abcoll.Container.__contains__ (   self,
  x 
) [inherited]
def _abcoll.Set.__eq__ (   self,
  other 
)

Definition at line 194 of file _abcoll.py.

00194 
00195     def __eq__(self, other):
00196         if not isinstance(other, Set):
00197             return NotImplemented
00198         return len(self) == len(other) and self.__le__(other)

Here is the call graph for this function:

Here is the caller graph for this function:

def _abcoll.Set.__ge__ (   self,
  other 
)

Definition at line 189 of file _abcoll.py.

00189 
00190     def __ge__(self, other):
00191         if not isinstance(other, Set):
00192             return NotImplemented
00193         return other <= self

def _abcoll.Set.__gt__ (   self,
  other 
)

Definition at line 184 of file _abcoll.py.

00184 
00185     def __gt__(self, other):
00186         if not isinstance(other, Set):
00187             return NotImplemented
00188         return other < self

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def _abcoll.Iterable.__iter__ (   self) [inherited]

Reimplemented in collections.UserDict, test.support.EnvironmentVarGuard, collections._ChainMap, _abcoll.Sequence, os._Environ, _abcoll.ItemsView, _abcoll.KeysView, shelve.Shelf, and _abcoll.Iterator.

Definition at line 69 of file _abcoll.py.

00069 
00070     def __iter__(self):
00071         while False:
00072             yield None

def _abcoll.Set.__le__ (   self,
  other 
)

Definition at line 169 of file _abcoll.py.

00169 
00170     def __le__(self, other):
00171         if not isinstance(other, Set):
00172             return NotImplemented
00173         if len(self) > len(other):
00174             return False
00175         for elem in self:
00176             if elem not in other:
00177                 return False
00178         return True

Here is the caller graph for this function:

def _abcoll.Sized.__len__ (   self) [inherited]
def _abcoll.Set.__lt__ (   self,
  other 
)

Definition at line 179 of file _abcoll.py.

00179 
00180     def __lt__(self, other):
00181         if not isinstance(other, Set):
00182             return NotImplemented
00183         return len(self) < len(other) and self.__le__(other)

Here is the call graph for this function:

def _abcoll.Set.__ne__ (   self,
  other 
)

Definition at line 199 of file _abcoll.py.

00199 
00200     def __ne__(self, other):
00201         return not (self == other)

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def _abcoll.Set.__or__ (   self,
  other 
)

Definition at line 222 of file _abcoll.py.

00222 
00223     def __or__(self, other):
00224         if not isinstance(other, Iterable):
00225             return NotImplemented
00226         chain = (e for s in (self, other) for e in s)
00227         return self._from_iterable(chain)

Here is the call graph for this function:

def _abcoll.Set.__sub__ (   self,
  other 
)

Definition at line 228 of file _abcoll.py.

00228 
00229     def __sub__(self, other):
00230         if not isinstance(other, Set):
00231             if not isinstance(other, Iterable):
00232                 return NotImplemented
00233             other = self._from_iterable(other)
00234         return self._from_iterable(value for value in self
00235                                    if value not in other)

Here is the call graph for this function:

Here is the caller graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def _abcoll.Iterable.__subclasshook__ (   cls,
  C 
) [inherited]

Reimplemented in _abcoll.Iterator.

Definition at line 74 of file _abcoll.py.

00074 
00075     def __subclasshook__(cls, C):
00076         if cls is Iterable:
00077             if any("__iter__" in B.__dict__ for B in C.__mro__):
00078                 return True
00079         return NotImplemented
00080 

Here is the call graph for this function:

def _abcoll.Sized.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 119 of file _abcoll.py.

00119 
00120     def __subclasshook__(cls, C):
00121         if cls is Sized:
00122             if any("__len__" in B.__dict__ for B in C.__mro__):
00123                 return True
00124         return NotImplemented
00125 

Here is the call graph for this function:

def _abcoll.Container.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 133 of file _abcoll.py.

00133 
00134     def __subclasshook__(cls, C):
00135         if cls is Container:
00136             if any("__contains__" in B.__dict__ for B in C.__mro__):
00137                 return True
00138         return NotImplemented
00139 

Here is the call graph for this function:

def _abcoll.Set.__xor__ (   self,
  other 
)

Definition at line 236 of file _abcoll.py.

00236 
00237     def __xor__(self, other):
00238         if not isinstance(other, Set):
00239             if not isinstance(other, Iterable):
00240                 return NotImplemented
00241             other = self._from_iterable(other)
00242         return (self - other) | (other - self)

Here is the call graph for this function:

def _abcoll.Set._from_iterable (   cls,
  it 
) [private]
Construct an instance of the class from any iterable input.

Must override this method if the class constructor signature
does not accept an iterable for an input.

Reimplemented in _abcoll.ItemsView, and _abcoll.KeysView.

Definition at line 203 of file _abcoll.py.

00203 
00204     def _from_iterable(cls, it):
00205         '''Construct an instance of the class from any iterable input.
00206 
00207         Must override this method if the class constructor signature
00208         does not accept an iterable for an input.
00209         '''
00210         return cls(it)

Here is the caller graph for this function:

def _abcoll.Set._hash (   self) [private]
Compute the hash value of a set.

Note that we don't define __hash__: not all sets are hashable.
But if you define a hashable set type, its __hash__ should
call this function.

This must be compatible __eq__.

All sets ought to compare equal if they contain the same
elements, regardless of how they are implemented, and
regardless of the order of the elements; so there's not much
freedom for __eq__ or __hash__.  We match the algorithm used
by the built-in frozenset type.

Definition at line 243 of file _abcoll.py.

00243 
00244     def _hash(self):
00245         """Compute the hash value of a set.
00246 
00247         Note that we don't define __hash__: not all sets are hashable.
00248         But if you define a hashable set type, its __hash__ should
00249         call this function.
00250 
00251         This must be compatible __eq__.
00252 
00253         All sets ought to compare equal if they contain the same
00254         elements, regardless of how they are implemented, and
00255         regardless of the order of the elements; so there's not much
00256         freedom for __eq__ or __hash__.  We match the algorithm used
00257         by the built-in frozenset type.
00258         """
00259         MAX = sys.maxsize
00260         MASK = 2 * MAX + 1
00261         n = len(self)
00262         h = 1927868237 * (n + 1)
00263         h &= MASK
00264         for x in self:
00265             hx = hash(x)
00266             h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167
00267             h &= MASK
00268         h = h * 69069 + 907133923
00269         h &= MASK
00270         if h > MAX:
00271             h -= MASK + 1
00272         if h == -1:
00273             h = 590923713
00274         return h
00275 
00276 Set.register(frozenset)
00277 

def _abcoll.Set.isdisjoint (   self,
  other 
)

Definition at line 216 of file _abcoll.py.

00216 
00217     def isdisjoint(self, other):
00218         for value in other:
00219             if value in self:
00220                 return False
00221         return True

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:


The documentation for this class was generated from the following file: