Get the first defined key in data.
    :param data:
    :type data:
    :param keys:
    :type keys:
    :param default_value:
    :type default_value:
    :return:
    :rtype:
331990
def get_first_defined(data, keys, default_value=None):
    
    for key in keys:
        if key in data:
            return data[key]
    return default_value
559183
public static function get($data, $key, $default = null)
    {
        if (self::isArrayAccess($data)) {
            return self::getArray($data, $key, $default);
        }
        if (is_object($data)) {
            return self::getObj($data, $key, $default);
        }

        return $default;
    }
122301
def get(self, key, default=None):
		
		if key in self._nodes: return self._nodes[key]
		else: return default
1320050
def load_from_data(self, data, with_undefined=False):
        
        if with_undefined:
            defined_values, undefined_values = data
        else:
            defined_values = data
            undefined_values = None
        self._index = defaultdict(list, defined_values)
        self._reverse_index = defaultdict(list)
        for key, values in self._index.items():
            for value in values:
                self._reverse_index[value].append(key)
        if undefined_values:
            self._undefined_keys = {key: True for key in undefined_values}
        else:
            self._undefined_keys = {}
972368
def get(self, key, default=None):
        
        val = self._store.get(key)

        if val is None:
            return value(default)

        return val
971679
def get_json(self, key, default=None):
        
        value = self.get_str(key)
        if value is not None:
            value = from_json(value)
            if value is not None:
                return value

        if isinstance(default, (dict, list)):
            return default

        return from_json(default)
1142859
def filter_keys(cls, data):
        
        keys = list(data.keys())
        for pattern in cls.EXCLUDE_PATTERNS:
            for key in keys:
                if re.match(pattern, key):
                    keys.remove(key)
        return dict(filter(lambda x: x[0] in keys, data.items()))
862394
def getlist(self, key, default=[]):
        
        if key in self:
            return [node.value for node in self._map[key]]
        return default
25582
def get(key, node=None, default=None):
    
    d = AppData.get_by_key(key)
    if d:
        data = utils.dict_dot(d)
        return data.get(node, default) if node else data
    return {}
587140
def get(self, key, default=None):
        
        try:
            return self[key]
        except KeyError:
            return default or self._default
449412
def get(self, key, default=None):
        
        result = self._loads(self._client.get(self.get_key(key)))
        if result is not None:
            return result
        else:
            return default or self._default
112827
def first_value_of(self, name, default_value = None):
        
        vals = self.values_of(name)
        if vals is not None:
            return vals if type(vals) is not list else vals[0]
        return default_value
1058516
def create_key_for_data(prefix, data, key_params):
    
    d = data.get_data()
    values = []
    for k in key_params:
        if k in d and type(d[k]) is list:
            values.append("{0}:{1}".format(k, " -".join(d[k])))
        else:
            value = d[k] if k in d else ''
            values.append("{0}:{1}".format(k, value))

    return "{0}-{1}".format(prefix, "-".join(values))
368785
def _get_value(data_structure, key):
    
    if len(key) == 0:
        raise KeyError()
    value = data_structure[key[0]]
    if len(key) > 1:
        return _get_value(value, key[1:])
    return value
384669
def buildData(self, key, default=None):
        
        return self._buildData.get(nativestring(key), default)
803835
def get(self, key, default=None):
        
        if hasattr(self.obj, key):
            return getattr(self.obj, key)
        return self.data.get(key, default)
1060402
def get(self, key, *val):
        
        data = self.get_data()
        if data is not None:
            return data.get(key, *val)
        if val:
            return val[0]
        raise KeyError(key)