Converts map element into a float or returns None if conversion is not possible.

        :param key: an index of element to get.

        :return: float value of the element or None if conversion is not supported.
765521
def get_as_nullable_float(self, key):
        
        value = self.get(key)
        return FloatConverter.to_nullable_float(value)
680736
public T get(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		long m = elementKeys[index];
		if (key == m) {
			return elementValues[index];
		}

		return null;
	}
560816
def get_as_boolean(self, key):
        
        value = self.get(key)
        return BooleanConverter.to_boolean(value)
1321396
public function getFloatValue($key)
    {
        $value = $this->get($key);
        if ($value === null) {
            return null;
        }
        return (float)$value;
    }
1206809
def pop_float(self, key: str, default: Any = DEFAULT) -> float:
        
        value = self.pop(key, default)
        if value is None:
            return None
        else:
            return float(value)
710793
public float getFloat(String key, float defaultValue) {
    if (containsKey(key)) {
      return Float.parseFloat(get(key));
    } else {
      return defaultValue;
    }
  }
513857
def get(self, key):
        
        value = self._redis.get(self._prefix + key)

        if value is not None:
            return self.unserialize(value)
487308
public float[] getFloatArray(final String key) {
		final String[] value = getArray(key);
		if (value != null) {
			final float[] result = new float[value.length];
			for (int i = 0; i < value.length; i++) {
				result[i] = Float.parseFloat(value[i]);
			}
			return result;
		}
		return null;
	}
738358
def get(self, key):
        

        if isinstance(key, tuple):
            # TODO handle different ordering
            try:
                x, y = float(key[0]), float(key[1])
            except IndexError:
                raise ValueError("Two values are required for a coordinate pair")

            except ValueError:
                raise ValueError("Only float or float-coercable values can be passed")

            key = "{0},{1}".format(x, y)

        return self[self.lookups[key]]
522026
public float getFloat(Enum<?> key, float defaultValue)
    {
        if (key == null)
        {
            return defaultValue;
        }

        return getFloat(key.name(), defaultValue);
    }
1035103
def max(self, key=None):
        

        def _max(result, item):
            val = data_get(item, key)

            if result is None or val > result:
                return value

            return result

        return self.reduce(_max)
908966
public Float getAsFloat(String key) {
        Object value = mValues.get(key);
        try {
            return value != null ? ((Number) value).floatValue() : null;
        } catch (ClassCastException e) {
            if (value instanceof CharSequence) {
                try {
                    return Float.valueOf(value.toString());
                } catch (NumberFormatException e2) {
                    DLog.e(TAG, "Cannot parse Float value for " + value + " at key " + key);
                    return null;
                }
            } else {
                DLog.e(TAG, "Cannot cast value for " + key + " to a Float: " + value, e);
                return null;
            }
        }
    }
515697
public float getFloat(String key) {
    if (containsKey(key)) {
      return Float.parseFloat(get(key));
    } else {
      throw new IllegalArgumentException("Missing key " + key + ".");
    }
  }
784131
public static float getFloat(final String key, final float def) {
		try {
			return systemRoot.getFloat(fixKey(key), def);
		} catch (final Exception e) {
			// just eat the exception to avoid any system
			// crash on system issues
			return def;
		}
	}
230825
def get_as_nullable_map(self, key):
        
        value = self.get_as_object(key)
        return AnyValueMap.from_value(value)
613210
def get_int(self, key, default=None):
        
        value = self.get(key, default)
        return None if value is None else int(value)
896037
def dictlist_convert_to_float(dict_list: Iterable[Dict], key: str) -> None:
    
    for d in dict_list:
        try:
            d[key] = float(d[key])
        except ValueError:
            d[key] = None