我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用collections.Set()。
def objwalk(obj, path=(), memo=None): if memo is None: memo = set() iterator = None if isinstance(obj, Mapping): iterator = iteritems elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types): iterator = enumerate if iterator: if id(obj) not in memo: memo.add(id(obj)) for path_component, value in iterator(obj): for result in objwalk(value, path + (path_component,), memo): yield result memo.remove(id(obj)) else: yield path, obj # optional test code from here on
def __call__(self, *args, **kwargs): """ Executes child computations in parallel. :arg args: list of values to the placeholders specified in __init__ *args :return: tuple of return values, one per return specified in __init__ returns list. """ args = self.unpack_args_or_feed_dict(args, kwargs) for child in itervalues(self.child_computations): child.feed_input([args[i] for i in child.param_idx]) return_vals = dict() for child in itervalues(self.child_computations): return_vals.update(child.get_results()) if isinstance(self.computation_op.returns, Op): return return_vals[self.computation_op.returns] elif isinstance(self.computation_op.returns, (collections.Sequence, OrderedSet)): return tuple(return_vals[op] for op in self.computation_op.returns) elif isinstance(self.computation_op.returns, collections.Set): return return_vals else: return None
def test_MutableMapping_subclass(self): # Test issue 9214 mymap = UserDict() mymap['red'] = 5 self.assertIsInstance(mymap.keys(), Set) self.assertIsInstance(mymap.keys(), KeysView) self.assertIsInstance(mymap.items(), Set) self.assertIsInstance(mymap.items(), ItemsView) mymap = UserDict() mymap['red'] = 5 z = mymap.keys() | {'orange'} self.assertIsInstance(z, set) list(z) mymap['blue'] = 7 # Shouldn't affect 'z' self.assertEqual(sorted(z), ['orange', 'red']) mymap = UserDict() mymap['red'] = 5 z = mymap.items() | {('orange', 3)} self.assertIsInstance(z, set) list(z) mymap['blue'] = 7 # Shouldn't affect 'z' self.assertEqual(sorted(z), [('orange', 3), ('red', 5)])
def test_abc_registry(self): d = dict(a=1) self.assertIsInstance(d.viewkeys(), collections.KeysView) self.assertIsInstance(d.viewkeys(), collections.MappingView) self.assertIsInstance(d.viewkeys(), collections.Set) self.assertIsInstance(d.viewkeys(), collections.Sized) self.assertIsInstance(d.viewkeys(), collections.Iterable) self.assertIsInstance(d.viewkeys(), collections.Container) self.assertIsInstance(d.viewvalues(), collections.ValuesView) self.assertIsInstance(d.viewvalues(), collections.MappingView) self.assertIsInstance(d.viewvalues(), collections.Sized) self.assertIsInstance(d.viewitems(), collections.ItemsView) self.assertIsInstance(d.viewitems(), collections.MappingView) self.assertIsInstance(d.viewitems(), collections.Set) self.assertIsInstance(d.viewitems(), collections.Sized) self.assertIsInstance(d.viewitems(), collections.Iterable) self.assertIsInstance(d.viewitems(), collections.Container)
def validate_type(data, type_): instance_check = False abstract_types = {typing.AbstractSet, typing.Sequence, typing.Mapping} if hasattr(type_, '__origin__') and type_.__origin__ in abstract_types: param_type = get_abstract_param_types(type_) imp_types = { typing.AbstractSet: collections.Set, typing.Sequence: collections.Sequence, typing.Mapping: collections.Mapping, } instance_check = isinstance(data, imp_types[type_.__origin__]) and \ all(isinstance(item, param_type[0]) for item in data) else: try: instance_check = isinstance(data, type_) except TypeError: if is_union_type(type_): instance_check = any( isinstance(data, t) for t in get_union_types(type_) ) else: raise ValueError('{!r} cannot validated.'.format(type_)) return instance_check
def serialize_meta(data): if hasattr(data, '__nirum_serialize__'): d = data.__nirum_serialize__() elif isinstance(data, (string_types, bool, int, float)): # FIXME: str in py2 represents binary string as well as text string. # It should be refactored so that the function explicitly takes # an expected type as like deserialize_meta() does. d = data elif (isinstance(data, datetime.datetime) or isinstance(data, datetime.date)): d = data.isoformat() elif isinstance(data, decimal.Decimal) or isinstance(data, uuid.UUID): d = str(data) elif (isinstance(data, collections.Set) or isinstance(data, collections.Sequence)): d = [serialize_meta(e) for e in data] elif isinstance(data, collections.Mapping): d = [ {'key': serialize_meta(k), 'value': serialize_meta(v)} for k, v in data.items() ] else: d = data return d
def _make_cmp(self, set_op, doc): "Make comparator method." def comparer(self, that): "Compare method for sorted set and set-like object." # pylint: disable=protected-access if isinstance(that, SortedSet): return set_op(self._set, that._set) elif isinstance(that, Set): return set_op(self._set, that) else: return NotImplemented comparer.__name__ = '__{0}__'.format(set_op.__name__) doc_str = 'Return True if and only if Set is {0} `that`.' comparer.__doc__ = doc_str.format(doc) return comparer
def __hash__(self): # taken from collections.Set max_i = sys.maxint mask = 2 * max_i + 1 n = len(self) h = 1927868237 * (n + 1) h &= mask for x in self: hx = hash(x) h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167 h &= mask h = h * 69069 + 907133923 h &= mask if h > max_i: h -= mask + 1 if h == -1: h = 590923713 return h
def getsize(top_obj): visited = set() def inner(obj): obj_id = id(obj) if obj_id in visited: return 0 visited.add(obj_id) size = sys.getsizeof(obj) if isinstance(obj, (str, bytes, Number, range, bytearray)): pass elif isinstance(obj, (tuple, list, Set, deque)): size += sum(inner(i) for i in obj) elif isinstance(obj, Mapping) or hasattr(obj, 'items'): size += sum(inner(k) + inner(v) for k, v in obj.items()) if hasattr(obj, '__dict__'): size += inner(vars(obj)) if hasattr(obj, '__slots__'): size += sum( inner(getattr(obj, s)) for s in obj.__slots__ if hasattr(obj, s)) return size return inner(top_obj)
def children(self, return_key=False): """Iterate over the children of this container. Args: return_key (bool): Set to :const:`True` to indicate that the return type should be a 2-tuple consisting of the child storage key and the child object. By default, only the child objects are returned. Returns: iterator of objects or (key,object) tuples """ if return_key: return enumerate(self._data) else: return self._data.__iter__() # # Define the Sequence abstract methods #
def __init__( self, types=None, # type: typing.Sequence[Union[type, Property]] name=None, # type: Optional[str] required=False, # type: bool versions=None, # type: Optional[Sequence[Union[str, Version]]] name_space=None, # type: Optional[str] prefix=None, # type: Optional[str] attribute=False, # type: bool ): if isinstance(types, (type, Property)): types = (types,) else: types = copy(types) self.types = types # type: Optional[Sequence[type]] self.name = name self.required = required self._versions = None # type: Optional[Union[Mapping[str, Optional[Property]], Set[Union[str, Number]]]] self.versions = versions # type: Optional[Union[Mapping[str, Optional[Property]], Set[Union[str, Number]]]] self.name_space = name_space # type: Optional[str] self.prefix = prefix # type: Optional[str] self.attribute = attribute # type: Optional[str]
def versions( self, versions # type: Optional[Sequence[Union[str, Version]]] ): # type: (...) -> Optional[Union[Mapping[str, Optional[Property]], Set[Union[str, Number]]]] if versions is not None: if isinstance(versions, (str, Number, meta.Version)): versions = (versions,) if isinstance(versions, Iterable): versions = tuple( (v if isinstance(v, meta.Version) else meta.Version(v)) for v in versions ) else: raise TypeError( '``Property.versions`` requires a sequence of version strings or ' + '``serial.properties.metadata.Version`` instances, not ' + '``%s``.' % type(versions).__name__ ) self._versions = versions
def __init__( self, types=None, # type: Optional[Sequence[Union[type, Property]]] values=None, # type: Optional[Union[typing.Sequence, typing.Set]] name=None, # type: Optional[str] required=False, # type: bool versions=None, # type: Optional[typing.Collection] name_space=None, # type: Optional[str] prefix=None, # type: Optional[str] attribute=False, # type: bool ): super().__init__( types=types, name=name, required=required, versions=versions, name_space=name_space, prefix=prefix, attribute=attribute ) self._values = None self.values = values # type: Optional[typing.Sequence]
def process_inline_members_definition(members): """ :param members: this can be any of the following: - a string containing a space and/or comma separated list of names: e.g.: "item1 item2 item3" OR "item1,item2,item3" OR "item1, item2, item3" - tuple/list/Set of strings (names) - Mapping of (name, data) pairs - any kind of iterable that yields (name, data) pairs :return: An iterable of (name, data) pairs. """ if isinstance(members, str): members = ((name, UNDEFINED) for name in members.replace(',', ' ').split()) elif isinstance(members, (tuple, list, collections.Set)): if members and isinstance(next(iter(members)), str): members = ((name, UNDEFINED) for name in members) elif isinstance(members, collections.Mapping): members = members.items() return members
def _is_set(self, value): if isinstance(value, Set): return True return False
def __setitem__(self, key, value): """Set `d[key]` to *value*.""" if key not in self: self._list_add(key) self._setitem(key, value)
def _make_cmp(set_op, doc): def comparer(self, that): if isinstance(that, SortedSet): return set_op(self._set, that._set) elif isinstance(that, Set): return set_op(self._set, that) else: raise TypeError('can only compare to a Set') comparer.__name__ = '__{0}__'.format(set_op.__name__) comparer.__doc__ = 'Return True if and only if ' + doc return comparer
def test_Set(self): for sample in [set, frozenset]: self.assertIsInstance(sample(), Set) self.assertTrue(issubclass(sample, Set)) self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__') class MySet(Set): def __contains__(self, x): return False def __len__(self): return 0 def __iter__(self): return iter([]) self.validate_comparison(MySet())
def test_hash_Set(self): class OneTwoThreeSet(Set): def __init__(self): self.contents = [1, 2, 3] def __contains__(self, x): return x in self.contents def __len__(self): return len(self.contents) def __iter__(self): return iter(self.contents) def __hash__(self): return self._hash() a, b = OneTwoThreeSet(), OneTwoThreeSet() self.assertTrue(hash(a) == hash(b))
def getsize(obj): """ Recursively iterate to sum size of object & members. Returns ------- size : int The size of the object in units of "Bytes". Credit ------ * How do I determine the size of an object in Python? https://stackoverflow.com/a/30316760/4856091 """ zero_depth_bases = (str, bytes, Number, range, bytearray) def inner(obj, _seen_ids=set()): obj_id = id(obj) if obj_id in _seen_ids: return 0 _seen_ids.add(obj_id) size = sys.getsizeof(obj) if isinstance(obj, zero_depth_bases): # bypass remaining control flow and return pass elif isinstance(obj, (tuple, list, Set, deque)): size += sum(inner(i) for i in obj) elif isinstance(obj, Mapping) or hasattr(obj, "items"): size += sum(inner(k) + inner(v) for k, v in obj.items()) # Check for custom object instances - may subclass above too if hasattr(obj, "__dict__"): size += inner(vars(obj)) if hasattr(obj, "__slots__"): # can have ``__slots__`` with ``__dict__`` size += sum(inner(getattr(obj, s)) for s in obj.__slots__ if hasattr(obj, s)) return size return inner(obj)
def machine(): """ Return machine suffix to use in directory name when looking for bootloader. PyInstaller is reported to work even on ARM architecture. For that case functions system() and architecture() are not enough. Path to bootloader has to be composed from system(), architecture() and machine() like: 'Linux-32bit-arm' """ mach = platform.machine() if mach.startswith('arm'): return 'arm' else: # Assume x86/x86_64 machine. return None # Set and get environment variables does not handle unicode strings correctly # on Windows. # Acting on os.environ instead of using getenv()/setenv()/unsetenv(), # as suggested in <http://docs.python.org/library/os.html#os.environ>: # "Calling putenv() directly does not change os.environ, so it's # better to modify os.environ." (Same for unsetenv.)
def test_issue16373(self): # Recursion error comparing comparable and noncomparable # Set instances class MyComparableSet(Set): def __contains__(self, x): return False def __len__(self): return 0 def __iter__(self): return iter([]) class MyNonComparableSet(Set): def __contains__(self, x): return False def __len__(self): return 0 def __iter__(self): return iter([]) def __le__(self, x): return NotImplemented def __lt__(self, x): return NotImplemented cs = MyComparableSet() ncs = MyNonComparableSet() # Run all the variants to make sure they don't mutually recurse ncs < cs ncs <= cs ncs > cs ncs >= cs cs < ncs cs <= ncs cs > ncs cs >= ncs
def __iter__(self): """ Return an iterator over the Set. Elements are iterated in their sorted order. Iterating the Set while adding or deleting values may raise a `RuntimeError` or fail to iterate over all entries. """ return iter(self._list)
def __reversed__(self): """ Return an iterator over the Set. Elements are iterated in their reverse sorted order. Iterating the Set while adding or deleting values may raise a `RuntimeError` or fail to iterate over all entries. """ return reversed(self._list)
def ContainsNoDuplicates(self): # Dictionaries and Sets have unique members by definition; avoid iterating. if isinstance(self._actual, (collections.Mapping, collections.Set)): return duplicates = [] entries = set() for i in self._actual: if i in entries: duplicates.append(i) entries.add(i) if duplicates: self._FailWithSubject( 'has the following duplicates: <{0}>'.format(duplicates))
