remove the item by key
        If not default is specified, raise KeyError if nothing
        could be removed.
        Return 'default' if specified and nothing could be removed
490997
def pop(self, key, default=_marker):
        
        try:
            popped = self[key]
            del self[key]
            return popped
        except KeyError:
            if default == _marker:
                raise
            return default
891562
def setdefault(self, key, default=None):
        
        if key in self.cache:
            return self.cache[key]

        def setdefault_trans(pipe):
            pickled_key = self._pickle_key(key)

            pipe.multi()
            pipe.hsetnx(self.key, pickled_key, self._pickle_value(default))
            pipe.hget(self.key, pickled_key)

            __, pickled_value = pipe.execute()

            return self._unpickle(pickled_value)

        value = self._transaction(setdefault_trans)

        if self.writeback:
            self.cache[key] = value
        return value
758854
def remove(self, attr, item):
        
        return self.set(attr, operation.Remove([item]))
949113
def _remove_add_key(self, key):
        """"""
        if not hasattr(self, '_queue'):
            return  # haven't initialized yet, so don't bother
        if key in self._queue:
            self._queue.remove(key)
        self._queue.append(key)
        if self.maxsize == 0:
            return
        while len(self._queue) > self.maxsize:
            del self[self._queue[0]]
383039
def remove_defaults(self, *args):
        '''
        
        '''
        for arg in args:
            if arg not in self.defaults:
                raise KeyError('{0}'.format(arg))
        return self.discard_defaults(*args)
346653
def pop(self, key=NOT_SET, index=NOT_SET, d=NOT_SET):
		
		has_default = d is not NOT_SET

		if index is NOT_SET and key is not NOT_SET:
			index, value = self._pop_key(key, has_default)
		elif key is NOT_SET:
			key, index, value = self._pop_index(index, has_default)
		else:
			raise KEY_AND_INDEX_ERROR

		if index is None:
			return d
		else:
			self._fix_indices_after_delete(index)
			return value
1207169
def pop(key, default=None):
    '''
    
    '''
    store = load()
    val = store.pop(key, default)
    dump(store)
    return val
1222598
def pull(self, key, default=None):
        
        val = self.get(key, default)

        self.forget(key)

        return val
245498
def get(self, item, default=None):
        
        if hasattr(self, item):
            return getattr(self, item)
        try:
            return self.__getitem__(item)

        except KeyError:
            return default
587140
def get(self, key, default=None):
        
        try:
            return self[key]
        except KeyError:
            return default or self._default
491021
def pop(self, key, default=None):
        
        return self._dictionary.pop(key.lower(), default)
738953
def remove(self, item):
        ''''''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score
600620
def empty(key, dict):
    
    if key in dict.keys():
        if dict[key]:
            return False
    return True
787335
def removeItem(self, item):
        """"""
        try:
            self.tree.removeItem(item)
        except AttributeError, e:
            raise VersionError('Saved versions are immutable')
400818
def setdefault(self, key, default=None):
        
        if key in self:
            return self[key]
        else:
            self._setitem(key, default)
            self._list_add(key)
            return default
165780
def pop(self, key, *args, **kwargs):
        
        try:
            val = self[key]
        except KeyError:
            if len(args):
                return args[0]
            if "default" in kwargs:
                return kwargs["default"]
            raise

        try:
            del(self[key])
        except KeyError:
            pass

        return val
265169
def remove(self, item):
        
        self.items.pop(item)
        self._remove_dep(item)
        self.order = None
        self.changed(code_changed=True)