def quantile(self, q=<NUM_LIT:0.5>, axis=<NUM_LIT:0>, numeric_only=True,<EOL>interpolation='<STR_LIT>'):
self._check_percentile(q)<EOL>data = self._get_numeric_data() if numeric_only else self<EOL>axis = self._get_axis_number(axis)<EOL>is_transposed = axis == <NUM_LIT:1><EOL>if is_transposed:<EOL><INDENT>data = data.T<EOL><DEDENT>result = data._data.quantile(qs=q,<EOL>axis=<NUM_LIT:1>,<EOL>interpolation=interpolation,<EOL>transposed=is_transposed)<EOL>if result.ndim == <NUM_LIT:2>:<EOL><INDENT>result = self._constructor(result)<EOL><DEDENT>else:<EOL><INDENT>result = self._constructor_sliced(result, name=q)<EOL><DEDENT>if is_transposed:<EOL><INDENT>result = result.T<EOL><DEDENT>return result<EOL>
Return values at the given quantile over requested axis.

Parameters
----------
q : float or array-like, default 0.5 (50% quantile)
    Value between 0 <= q <= 1, the quantile(s) to compute.
axis : {0, 1, 'index', 'columns'} (default 0)
    Equals 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
numeric_only : bool, default True
    If False, the quantile of datetime and timedelta data will be
    computed as well.
interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
    This optional parameter specifies the interpolation method to use,
    when the desired quantile lies between two data points `i` and `j`:

    * linear: `i + (j - i) * fraction`, where `fraction` is the
      fractional part of the index surrounded by `i` and `j`.
    * lower: `i`.
    * higher: `j`.
    * nearest: `i` or `j` whichever is nearest.
    * midpoint: (`i` + `j`) / 2.

    .. versionadded:: 0.18.0

Returns
-------
Series or DataFrame

    If ``q`` is an array, a DataFrame will be returned where the
      index is ``q``, the columns are the columns of self, and the
      values are the quantiles.
    If ``q`` is a float, a Series will be returned where the
      index is the columns of self and the values are the quantiles.

See Also
--------
core.window.Rolling.quantile: Rolling quantile.
numpy.percentile: Numpy function to compute the percentile.

Examples
--------
>>> df = pd.DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),
...                   columns=['a', 'b'])
>>> df.quantile(.1)
a    1.3
b    3.7
Name: 0.1, dtype: float64
>>> df.quantile([.1, .5])
       a     b
0.1  1.3   3.7
0.5  2.5  55.0

Specifying `numeric_only=False` will also compute the quantile of
datetime and timedelta data.

>>> df = pd.DataFrame({'A': [1, 2],
...                    'B': [pd.Timestamp('2010'),
...                          pd.Timestamp('2011')],
...                    'C': [pd.Timedelta('1 days'),
...                          pd.Timedelta('2 days')]})
>>> df.quantile(0.5, numeric_only=False)
A                    1.5
B    2010-07-02 12:00:00
C        1 days 12:00:00
Name: 0.5, dtype: object