我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用collections.MutableSequence()。
def __init__( self, name=None, children=None, source_range=None, metadata=None ): item.Item.__init__( self, name=name, source_range=source_range, metadata=metadata ) collections.MutableSequence.__init__(self) self._children = [] if children: # cannot simply set ._children to children since __setitem__ runs # extra logic (assigning ._parent pointers). self.extend(children)
def update(self, d): """Like the dictionary .update() method. Update the data dictionary of this SerializableObject with the .data of d if d is a SerializableObject or if d is a dictionary, d itself. """ # use the parent update function super(Composition, self).update(d) # ...except for the 'children' field, which needs to run through the # insert method so that _parent pointers are correctly set on children. self._children = [] self.extend(d.get('children', [])) # @} # @{ collections.MutableSequence implementation
def __repr__(self): return ( "otio.{}(" "name={}, " "children={}, " "metadata={}" ")".format( self._class_path, repr(self.name), repr(self._children), repr(self.metadata) ) ) # @} # @{ collections.MutableSequence implementation
def prepend(self, container): """Insert objects at the start of the container""" if not isinstance(container, collections.MutableSequence): container = [container] container.reverse() for x in container: if self._current != x: try: self._container.remove(x) except ValueError: pass self._container.appendleft(x) try: self._container.remove(self._current) self._container.appendleft(self._current) except ValueError: pass if self._current is None and any(self._container): self._current = self._container[0]
def test_list(): immutable_list = List([1, 2]) with raises(AttributeError): immutable_list.append(1) with raises(TypeError): immutable_list + [3] assert isinstance(immutable_list, collections.Sequence) assert not isinstance(immutable_list, collections.MutableSequence) assert immutable_list[0] == 1 assert len(immutable_list) == 2 assert 2 in immutable_list assert next(iter(immutable_list)) == 1 assert immutable_list.index(2) == 1 assert immutable_list.count(1) == 1 assert immutable_list.count(2) == 1 assert immutable_list.count(3) == 0
def print_list(): cfg = get_config() meta = {'hostvars': {}} for alias, attributes in cfg.items(): tmp_dict = {} for az_opt, ans_opt in _az_to_ansible: if az_opt in attributes: # If the attribute is a list, just take the first element. # Private key is returned in a list for some reason. attr = attributes[az_opt] if isinstance(attr, MutableSequence): attr = attr[0] tmp_dict[ans_opt] = attr if tmp_dict: meta['hostvars'][alias] = tmp_dict print(json.dumps({_key: list(set(meta['hostvars'].keys())), '_meta': meta}))
def __init__(self, cell_size, default_list=list): """Initialize Args: cell_size (float): default_list (Callable[MutableSequence]): Must have append method. For example - ``list`` - ``SortedList`` - ``lambda: array(typecode)`` """ assert cell_size > 0 assert callable(default_list) self._cell_size = cell_size self._list = default_list self._blocks = defaultdict(default_list) self._str = \ "cell_size: {cell_size}\n" \ "default_list: {default_list}".format( cell_size=cell_size, default_list=default_list)
def remove_values(value, no_log_strings): """ Remove strings in no_log_strings from value. If value is a container type, then remove a lot more""" deferred_removals = deque() no_log_strings = [to_native(s, errors='surrogate_or_strict') for s in no_log_strings] new_value = _remove_values_conditions(value, no_log_strings, deferred_removals) while deferred_removals: old_data, new_data = deferred_removals.popleft() if isinstance(new_data, Mapping): for old_key, old_elem in old_data.items(): new_elem = _remove_values_conditions(old_elem, no_log_strings, deferred_removals) new_data[old_key] = new_elem else: for elem in old_data: new_elem = _remove_values_conditions(elem, no_log_strings, deferred_removals) if isinstance(new_data, MutableSequence): new_data.append(new_elem) elif isinstance(new_data, MutableSet): new_data.add(new_elem) else: raise TypeError('Unknown container type encountered when removing private values from output') return new_value
def modifies_known_mutable(obj, attr): """This function checks if an attribute on a builtin mutable object (list, dict, set or deque) would modify it if called. It also supports the "user"-versions of the objects (`sets.Set`, `UserDict.*` etc.) and with Python 2.6 onwards the abstract base classes `MutableSet`, `MutableMapping`, and `MutableSequence`. >>> modifies_known_mutable({}, "clear") True >>> modifies_known_mutable({}, "keys") False >>> modifies_known_mutable([], "append") True >>> modifies_known_mutable([], "index") False If called with an unsupported object (such as unicode) `False` is returned. >>> modifies_known_mutable("foo", "upper") False """ for typespec, unsafe in _mutable_spec: if isinstance(obj, typespec): return attr in unsafe return False
def flatten(d, sep='.'): """Flatten a data structure into tuples""" def _flatten(e, parent_key='', sep='.'): import collections prefix = parent_key + sep if parent_key else '' if isinstance(e, collections.MutableMapping): return tuple((prefix + k2, v2) for k, v in e.items() for k2, v2 in _flatten(v, k, sep)) elif isinstance(e, collections.MutableSequence): return tuple((prefix + k2, v2) for i, v in enumerate(e) for k2, v2 in _flatten(v, str(i), sep)) else: return (parent_key, (e,)), return tuple((k, v[0]) for k, v in _flatten(d, '', sep)) # From http://stackoverflow.com/a/2597440
def find_protos(proto_paths, excluded_proto_path): """Searches along `proto_paths` for .proto files and returns a generator of paths""" if not isinstance(proto_paths, (types.GeneratorType, collections.MutableSequence)): raise ValueError("proto_paths must be a list") for path in proto_paths: if os.path.isdir(path): for root, _, files in os.walk(path): for proto in files: is_excluded = _is_proto_excluded(os.path.join(root, proto), excluded_proto_path) if os.path.splitext(proto)[1] == '.proto' and not is_excluded: yield os.path.join(root, proto) elif os.path.isfile(path) and os.path.splitext(path)[1] == '.proto': yield path
def _transform_list(self, model, params, transformation, target_shape): if not isinstance(params, MutableSequence): return member_model = model.member member_shape = member_model.name for i, item in enumerate(params): if member_shape == target_shape: params[i] = transformation(item) else: self._transform_parameters( member_model, params[i], transformation, target_shape)
def __init__(self, serializers): if isinstance(serializers, collections.MutableSequence): self.serializers = serializers else: self.serializers = [serializers]
def __init__(self, iterable=None, owner=None, instance=None): try: self.seq = list(iterable) except TypeError: self.seq = list() self.owner = owner self.instance = instance # Sized -> Sequence -> MutableSequence (Abstract Method)
def __len__(self): return len(self.seq) # Iterable -> Sequence -> MutableSequence (Abstract Method)
def __iter__(self): return iter(self.seq) # Container -> Sequence -> MutableSequence (Abstract Method)
def __contains__(self, elem): return elem in self.seq # MutableSequence (Abstract Method)
def notify(self): if self.owner: self.owner.__set__(self.instance, self.seq) # MutableSequence (Abstract Method)
def __delitem__(self, key): del self.seq[key] self.notify() # MutableSequence (Abstract Method)
def test_MutableSequence(self): for sample in [tuple, str, bytes]: self.assertNotIsInstance(sample(), MutableSequence) self.assertFalse(issubclass(sample, MutableSequence)) for sample in [list, bytearray]: self.assertIsInstance(sample(), MutableSequence) self.assertTrue(issubclass(sample, MutableSequence)) self.assertFalse(issubclass(str, MutableSequence)) self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__', '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert') ################################################################################ ### Counter ################################################################################
def testRepeatedFieldsAreSequences(self, message_module): m = message_module.TestAllTypes() self.assertIsInstance(m.repeated_int32, collections.MutableSequence) self.assertIsInstance(m.repeated_nested_message, collections.MutableSequence)
def test_MutableSequence(self): for sample in [tuple, str]: self.assertNotIsInstance(sample(), MutableSequence) self.assertFalse(issubclass(sample, MutableSequence)) for sample in [list]: self.assertIsInstance(sample(), MutableSequence) self.assertTrue(issubclass(sample, MutableSequence)) self.assertFalse(issubclass(basestring, MutableSequence)) self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__', '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')
def append(self, container): """Insert objects at the end of the container""" if not isinstance(container, collections.MutableSequence): container = [container] for x in container: try: self._container.remove(x) except ValueError: pass self._container.append(x) if self._current is None and any(self._container): self._current = self._container[0]
def remove(self, container): """Remove objects from the container""" if not isinstance(container, collections.MutableSequence): container = [container] for x in container: try: self._container.remove(x) except ValueError: pass
