Use scipy.stats.percentileofscore:

# libs required
from scipy import stats
import pandas as pd
import numpy as np

# generate ramdom data with same seed (to be reproducible)
np.random.seed(seed=1)
df = pd.DataFrame(np.random.uniform(0, 1, (10)), columns=['a'])

# quantile function
x = df.quantile(0.5)[0]

# inverse of quantile
stats.percentileofscore(df['a'], x)

The value returned by the np.quantile function will depend on the interpolation behavior; there are a number of different ways to define "quantile", and numpy implements several of them. For more detail, see R. J. Hyndman and Y. Fan, “Sample quantiles in statistical packages,” The American Statistician, 50(4), pp. 361-365, 1996.

This is not much different from the situation as arises when estimating the median for a sample with an even sample size. See also: Definition of quantile

How np.quantile does interpolation is explained in the numpy documentation.

Given a vector V of length n, the q-th quantile of V is the value q of the way from the minimum to the maximum in a sorted copy of V. The values and distances of the two nearest neighbors as well as the method parameter will determine the quantile if the normalized ranking does not match the location of q exactly. This function is the same as the median if q=0.5, the same as the minimum if q=0.0 and the same as the maximum if q=1.0.

The optional method parameter specifies the method to use when the desired quantile lies between two indexes i and j = i + 1. In that case, we first determine i + g, a virtual index that lies between i and j, where i is the floor and g is the fractional part of the index. The final result is, then, an interpolation of a[i] and a[j] based on g. During the computation of g, i and j are modified using correction constants alpha and beta whose choices depend on the method used. Finally, note that since Python uses 0-based indexing, the code subtracts another 1 from the index internally.

The following formula determines the virtual index i + g, the location of the quantile in the sorted sample: $$ i + g = q \times (n - \alpha - \beta +1 ) + \alpha $$

This is straightforward to implement; this implementation matches numpy for method="linear", which is the default.

import numpy as np


def my_quantile(a, q):
    n = a.size
    alpha = 1.0
    beta = 1.0
    i = int(q * n)
    g = q * (n - alpha - beta + 1.0) + alpha - i
    a = np.sort(a)
    upper = a[i]
    lower = a[i - 1]
    return (upper - lower) * g + lower


if __name__ == "__main__":
    v = np.array([2, 3, 4, 10])
    print(v)
    q_val = np.quantile(v, 1.0 / 3.0, method="linear")
    me = my_quantile(a=v, q=1.0 / 3.0)
    print(f"numpy:\t{q_val}") # 3.0
    print(f"mine:\t{me}") # 3.0

    q_val = np.quantile(v, 0.25, method="linear")
    me = my_quantile(a=v, q=0.25)
    print(20 * "-")
    print(f"numpy:\t{q_val}") # 2.75
    print(f"mine:\t{me}") # 2.75

    prng = np.random.default_rng(42)
    norm_v = prng.normal(size=100)
    me = my_quantile(a=norm_v, q=0.25)
    print(20 * "-")
    print(f"numpy:\t{q_val}") # -0.5439015088644885
    print(f"mine:\t{me}") # -0.5439015088644885

Uses numpy version 1.24.3.

In comments, OP writes that they expect np.quantile(v, 0.25) to return 2. This is achieved by a different method than the default ”linear” method. If OP desires this behavior, then they should use np.quantile(v, 0.25, method='lower'), which returns 2.

Not a ready-made function but a compact and reasonably fast snippet:

(a<value).mean()

You can (at least on my machine) squeeze out a few percent better performance by using np.count_nonzero

np.count_nonzero(a<value) / a.size

but tbh I wouldn't even bother.