Return the last data value for the passed key. If key doesn't exist
        or value is an empty list, return `default`.
179780
def get(self, key, default=None, type_=None):
        
        try:
            rv = self[key]
        except KeyError:
            return default
        if type_ is not None:
            try:
                rv = type_(rv)
            except ValueError:
                rv = default
        return rv
1057597
def popitem(self, last=True):
		
		try:
			if last:
				key, value = self._list.pop()
				index = len(self._list)
			else:
				key, value = self._list.pop(0)
				index = 0
		except IndexError:
			raise KeyError("IndexedDict is empty")

		index2, value2 = self._dict.pop(key)
		assert index == index2
		assert value is value2

		if not last:
			self._fix_indices_after_delete()

		return key, value
612263
public int get(int key, int defaultValue) {
    int index = getKeyIndex(key);
    if (index >= 0) {
      return values[index];
    } else {
      return defaultValue;
    }
  }
643540
def _last_values(self):
        
        if not self.session.get('last_request_uri'):
            self.session.last_request_uri = None
        self.session.last_request_at = self.session.get('last_request_at', 0)
1130859
def try_pop(d, key, default):
    
    value = d.get(key, default)
    if key in d:
        d.pop(key)
    return value
173845
def get(self, conn, key, default=None):
        
        values, _ = yield from self._multi_get(conn, key)
        return values.get(key, default)
742616
def dynamize_last_evaluated_key(self, last_evaluated_key):
        
        d = None
        if last_evaluated_key:
            hash_key = last_evaluated_key['HashKeyElement']
            d = {'HashKeyElement': self.dynamize_value(hash_key)}
            if 'RangeKeyElement' in last_evaluated_key:
                range_key = last_evaluated_key['RangeKeyElement']
                d['RangeKeyElement'] = self.dynamize_value(range_key)
        return d
1195786
def get(self, key, default=None):
        
        if not isinstance(key, bytes):
            key = key.encode('utf8')

        return self.b_get_value(key) or default
180494
def last(self):
        """"""
        if len(self._range) == 0:
            raise IndexError("range is empty")
        if self._idx == -1:
            return self._range[0]
        return self._get(self._idx)
663152
def _get_first(self, keys, default=None):
        
        d = self.device
        for k in keys:
            v = d.get(k)
            if not v is None:
                return v
        return default
510246
def get(self, key, default=None):
        
        try:
            return self.items[key]
        except IndexError:
            return value(default)
742732
def get(self, key, default=None):
        
        """
        segments = key.split('.')
        result = reduce(
            lambda dct, k: dct and dct.get(k) or None,
            segments, self.data)

        return result or default
845714
def defaults(current: dict, *args: AnyMapping) -> dict:
    
    """
    for data in args:
        for key, value in data.items():
            current.setdefault(key, value)
    return current
744068
def get(self, key, default=None):
        """"""

        return self._data.get(key, compat_builtins.__dict__.get(key, default))
237055
def get(key, default=0)
      with_failure_grace(default) {
        val = @redis.get(key)
        return default if val.nil?
        val.numeric? ? val.to_i : val
      }
    end
1332354
def values(self, key=_absent):
        
        if key is not _absent and key in self._map:
            return self.getlist(key)
        return list(self.itervalues())
135758
def _cache_get_last_in_slice(url_dict, start_int, total_int, authn_subj_list):
    """"""
    key_str = _gen_cache_key_for_slice(url_dict, start_int, total_int, authn_subj_list)
    # TODO: Django docs state that cache.get() should return None on unknown key.
    try:
        last_ts_tup = django.core.cache.cache.get(key_str)
    except KeyError:
        last_ts_tup = None
    logging.debug('Cache get. key="{}" -> last_ts_tup={}'.format(key_str, last_ts_tup))
    return last_ts_tup