Remove the first key-value pair with key *key*.

        If a pair was removed, return its value. Otherwise if *default* was
        provided, return *default*. Otherwise a ``KeyError`` is raised.
4216
def pop(self, key, default=UNSET):
        
        self._find_lt(key)
        node = self._path[0][2]
        if node is self._tail or key < node[0]:
            if default is self.UNSET:
                raise KeyError('key {!r} not in list')
            return default
        self._remove(node)
        return node[1]
907169
def pop(self, key=util_const.NoParam, default=util_const.NoParam):
        
        # Dictionary pop if key is specified
        if key is not util_const.NoParam:
            if default is util_const.NoParam:
                return (key, self._dict.pop(key))
            else:
                return (key, self._dict.pop(key, default))
        # Otherwise do a heap pop
        try:
            # Ammortized O(1)
            _heap = self._heap
            _dict = self._dict
            val, key = self._heappop(_heap)
            # Remove items marked for lazy deletion as they are encountered
            while key not in _dict or _dict[key] != val:
                val, key = self._heappop(_heap)
        except IndexError:
            if len(_heap) == 0:
                raise IndexError('queue is empty')
            else:
                raise
        del _dict[key]
        return key, val
839411
def deleted(self, key, value):
    
    deleted = self.get('deleted')
    book_series = self.get('book_series')

    if not deleted:
        normalized_a_values = [el.upper() for el in force_list(value.get('a'))]
        normalized_c_values = [el.upper() for el in force_list(value.get('c'))]
        if 'DELETED' in normalized_a_values or 'DELETED' in normalized_c_values:
            deleted = True

    if not book_series:
        normalized_a_values = [el.upper() for el in force_list(value.get('a'))]
        if 'BOOKSERIES' in normalized_a_values:
            book_series = True

    self['book_series'] = book_series
    return deleted
224660
def del_key(self, ref):
        
        if ref not in self.keys:
            response = self.request("client_del_key %s" % (ref))
            self.keys.remove(ref)
            if "success" in response:
                return None
            else:
                return response
518239
def remove(self, key):
        """"""
        item = self.item_finder.pop(key)
        item[-1] = None
        self.removed_count += 1
510246
def get(self, key, default=None):
        
        try:
            return self.items[key]
        except IndexError:
            return value(default)
490997
def pop(self, key, default=_marker):
        
        try:
            popped = self[key]
            del self[key]
            return popped
        except KeyError:
            if default == _marker:
                raise
            return default
616762
def delete(key)
      raise BlankKeyError if key.blank?
      @backend.transaction{
        timestamp!(:last_modified)
        old_value = @backend[:user].delete(encrypt(key))
        raise KeyNotFoundError.new(key) unless old_value
        EntryMapper.from_json(decrypt(old_value))
      }
    end
532548
def delete(self, key):
        
        data = None
        if key is not None:
            data = self.db.delete(key.strip())
        else:
            self.tcex.log.warning(u'The key field was None.')
        return data
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
11965
function del(/* key-1, key-N, req */) {
  var args = slice.call(arguments, 0)
    , req = typeof args[args.length-1] === 'object' ? args.pop() : null;
  var deleted = 0;
  for(var i = 0;i < args.length;i++) {
    if(this.keyExists(args[i])) {
      this.delKey(args[i], req);
      deleted++;
    }
  }
  return deleted;
}
1176932
def _default(self, key, default=None):
        
        try:
            value = self.theme.themeables.property(key)
        except KeyError:
            value = None

        return value if value is not None else default
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)
519646
def curry_pair_dictionary(key_pair_dict, default_value=0.0):
    
    result = defaultdict(dict)
    for (a, b), value in key_pair_dict.items():
        result[a][b] = value
    return result
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)
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
288790
def _set_default_key(mapping):
        """"""
        key_longest = sorted([(len(v), k) for k, v in mapping.items()],
                             reverse=True)[0][1]
        mapping['default'] = key_longest
        del (mapping[key_longest])