Get a parameter value by name

        Args:
            name: The name of the parameter
509056
def get_parameter(self, name):
        
        i = self.get_parameter_names(include_frozen=True).index(name)
        return self.get_parameter_vector(include_frozen=True)[i]
562111
def _get_key_values(self, name):
        
        results = {}

        for key, value in self.qs.items():
            try:
                if not key.startswith(name):
                    continue

                key_start = key.index('[') + 1
                key_end = key.index(']')
                item_key = key[key_start:key_end]

                if ',' in value:
                    item_value = value.split(',')
                else:
                    item_value = value
                results.update({item_key: item_value})
            except Exception:
                raise BadRequest("Parse error", source={'parameter': key})

        return results
1261573
def cls_get_by_name(cls, name):
    
    try:
        val = getattr(cls, name)
    except AttributeError:
        for attr in (a for a in dir(cls) if not a.startswith('_')):
            try:
                val = getattr(cls, attr)
            except AttributeError:
                # Is known to happen.
                continue
            valname = getattr(val, 'name', None)
            if valname == name:
                return val
        else:
            raise ValueError('No {} with that name: {}'.format(
                cls.__name__,
                name,
            ))
    else:
        return val
32695
public String findParameterAliasByName(String name) {
		if (parameterName2Alias.containsKey(name)) {
			return parameterName2Alias.get(name);
		}

		return name;
	}
479526
def select_param(param_name, default=None):
    

    def select_param(_value, _context, **params):
        return params.pop(param_name, default)

    return select_param
592276
public ParameterValue getQueryParameter(String name) {
        if (!getQueryParameters().containsKey(name)) {
            return buildParameterValue();
        }

        return getQueryParameters().get(name);
    }
41455
def get_value(self, name):
        
        factory = self._registered.get(name)
        if not factory:
            raise KeyError('Name not registered')
        if factory._giveme_singleton:
            if name in self._singletons:
                return self._singletons[name]
            self._singletons[name] = factory()
            return self._singletons[name]
        elif factory._giveme_threadlocal:
            if hasattr(self._threadlocals, name):
                return getattr(self._threadlocals, name)
            setattr(self._threadlocals, name, factory())
            return getattr(self._threadlocals, name)
        return factory()
999072
def parameter(self, name=None, value=None, **kwargs):
        
        return self.nest(Parameter(name=name, value=value, **kwargs))
1142558
def getParam(self, name=None):
        
        if 'parameters' in self.keys():
            l = {x['name']: x['value'] for x in self['parameters'].values()}
            if name:
                if name in l.keys():
                    return l[name]
                else:
                    return False
            else:
                return l
709172
private List<String> getParameterAsList(String name) {
        String[] values = getParameterValues(name);
        if (values == null) {
            return null;
        }

        List<String> valueList = new ArrayList<>(values.length);
        Collections.addAll(valueList, values);
        return valueList;
    }
929141
def get(self, name):
        
        # read the attribute
        attr = getattr(self.context, name, None)
        if callable(attr):
            return attr()
        return attr
1346343
def require(self, name):
        """"""
        value = self.get(name)
        if value is None:
            raise TypeError(
                "{0} requires the parameter '{1}'.".format(
                    self.__class__, name
                )
            )
        return value
895242
def get_configurable_by_name(self, name):
        
        l = [c for c in self.configurables if c.name == name]
        if l:
            return l[0]
423710
def getParameterValue(self, parameterName):
        
        if  self._results is None:
            self.__init()
        parameter = self._results[parameterName]
        return parameter
1331690
@Override
    public String getParameter(String name) {
        String[] vals = getParameterMap().get(name);

        return (vals != null && vals.length > 0) ? vals[0] : null;
    }
1315365
public String getParameter( String name )
    {
        if (_parameters == null || !_parameters.hasParameters())
            return null;

        List parameters = _parameters.getParameterValues(name);
        if(parameters != null && parameters.size() > 0)
            return (String)parameters.get(0);
        else return null;
    }
148967
def _get_required_param(self, param_name):
    
    value = self.request.get(param_name)
    if not value:
      raise errors.NotEnoughArgumentsError(param_name + " not specified")
    return value