code: def kurtosis(a, axis=0, fisher=True, bias=True):
      """
      Computes the kurtosis (Fisher or Pearson) of a dataset.
  
      Kurtosis is the fourth central moment divided by the square of the
      variance. If Fisher's definition is used, then 3.0 is subtracted from
      the result to give 0.0 for a normal distribution.
  
      If bias is False then the kurtosis is calculated using k statistics to
      eliminate bias coming from biased moment estimators
  
      Use `kurtosistest` to see if result is close enough to normal.
  
      Parameters
      ----------
      a : array
          data for which the kurtosis is calculated
      axis : int or None, optional
          Axis along which the kurtosis is calculated. Default is 0.
          If None, compute over the whole array `a`.
      fisher : bool, optional
          If True, Fisher's definition is used (normal ==> 0.0). If False,
          Pearson's definition is used (normal ==> 3.0).
      bias : bool, optional
          If False, then the calculations are corrected for statistical bias.
  
      Returns
      -------
      kurtosis : array
          The kurtosis of values along an axis. If all values are equal,
          return -3 for Fisher's definition and 0 for Pearson's definition.
  
      Notes
      -----
      For more details about `kurtosis`, see `stats.kurtosis`.
  
      """
      a, axis = _chk_asarray(a, axis)
      m2 = moment(a, 2, axis)
      m4 = moment(a, 4, axis)
      olderr = np.seterr(all="ignore")
      try:
          vals = ma.where(m2 == 0, 0, m4 / m2**2.0)
      finally:
          np.seterr(**olderr)
  
      if not bias:
          n = a.count(axis)
          can_correct = (n > 3) & (m2 is not ma.masked and m2 > 0)
          if can_correct.any():
              n = np.extract(can_correct, n)
              m2 = np.extract(can_correct, m2)
              m4 = np.extract(can_correct, m4)
              nval = (
                  1.0
                  / (n - 2)
                  / (n - 3)
                  * (
                      (n * n - 1.0) * m4 / m2**2.0
                      - 3 * (n - 1) ** 2.0
                  )
              )
              np.place(vals, can_correct, nval + 3.0)
      if fisher:
          return vals - 3
      else:
          return vals
  
imports: from __future__ import division, print_function, absolute_import
  import numpy
  from numpy import ndarray
  import numpy.ma
  from numpy.ma import masked, nomask
  from scipy._lib.six import iteritems
  import itertools
  import warnings
  from collections import namedtuple
  from .None import distributions
  import scipy.special
  from ._stats_mstats_common import _find_repeats, linregress, theilslopes, siegelslopes
label_desc: Use image node_id 45 for calling a global function with example usage: kurtosis(a, axis, fisher, bias) and returns: unknown, vals