Remove specified key and return the corresponding value.
           If key is not found, default is returned if given, otherwise 
           KeyError is raised.
493072
def pop(self, key, default=None):
        
        if key not in self:
            if default is not None:
                return default
            raise KeyError(key)
        for map in [self._pb.IntMap, self._pb.FloatMap, self._pb.StringMap,
                    self._pb.BoolMap]:
            if key in map.keys():
                return map.pop(key)
483754
def pop_int(self, key: str, default: Any = DEFAULT) -> int:
        
        value = self.pop(key, default)
        if value is None:
            return None
        else:
            return int(value)
1285813
def getkey(mapping, value, default=None, use_id=False):
    '''
    '''
    if use_id:
        for key, val in mapping.items():
            if val is value:
                return key
    else:
        for key, val in mapping.items():
            if val == value:
                return key
    return default
170851
def get(self, key):
        
        data = self._store.get(key)
        if not data:
            return None
        value, expire = data
        if expire and time.time() > expire:
            del self._store[key]
            return None
        return value
864937
def unset(self, key):
        
        params = {
            'key': key
        }
        return self.client.delete(self._url(), params=params)
896068
def remove_key(self, key):
        """"""
        try:
            self._own_keys.discard(key)
            if self._parent and self._parent.has_key(key):
                self._container[key] = self._parent[key]
            else:
                del self._container[key]
        except KeyError:
            pass
379314
def pop(self, key, default):
        """"""
        with self._lock:
            return self._dict.pop(key, default)
52023
def get(self, key, default=None):
        '''
        
        '''
        valu = self.data.get(key, default)
        if key in self.data:
            self.data.move_to_end(key)
        return valu
915785
def value(self, key, default=None):
        
        curr = self._stack[-1]
        return curr.get(key, default)
1177123
def get(self, key: Any, default: Any = None) -> Any:
        
        if key in self:
            return self[key].value
        return default
419543
def get(self, key, default=None):
        
        try:
            index = self.__keys.index(str(key))
        except ValueError:
            return default
        if 0 <= index < len(self):
            return super(Record, self).__getitem__(index)
        else:
            return default
337990
def setdefault(self, key, default=None):
        
        self._wlock.acquire()
        try:
            try:
                return self[key]
            except KeyError:
                self[key] = default
                return default
        finally:
            self._wlock.release()
972368
def get(self, key, default=None):
        
        val = self._store.get(key)

        if val is None:
            return value(default)

        return val
925540
def pop(self, key, default=None):
        
        with self.lock:
            try:
                item = OrderedDict.__getitem__(self, key)
                del self[key]
                return item[0]
            except KeyError:
                return default
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
439181
def unset(self, key):
        
        key = key.strip().upper()
        if key not in dir(default_settings) and key not in self._defaults:
            self.logger.debug("Unset %s", key)
            delattr(self, key)
            self.store.pop(key, None)
476541
def remove(self, key):
        
        self._find_lt(key)
        node = self._path[0][2]
        if node is self._tail or key < node[0]:
            raise KeyError('{!r} is not in list'.format(key))
        self._remove(node)