code: def resample(*arrays, **options):
      """Resample arrays or sparse matrices in a consistent way
  
      The default strategy implements one step of the bootstrapping
      procedure.
  
      Parameters
      ----------
      *arrays : sequence of indexable data-structures
          Indexable data-structures can be arrays, lists, dataframes or scipy
          sparse matrices with consistent first dimension.
  
      replace : boolean, True by default
          Implements resampling with replacement. If False, this will implement
          (sliced) random permutations.
  
      n_samples : int, None by default
          Number of samples to generate. If left to None this is
          automatically set to the first dimension of the arrays.
          If replace is False it should not be larger than the length of
          arrays.
  
      random_state : int or RandomState instance
          Control the shuffling for reproducible behavior.
  
      Returns
      -------
      resampled_arrays : sequence of indexable data-structures
          Sequence of resampled views of the collections. The original arrays are
          not impacted.
  
      Examples
      --------
      It is possible to mix sparse and dense arrays in the same run::
  
        >>> X = np.array([[1., 0.], [2., 1.], [0., 0.]])
        >>> y = np.array([0, 1, 2])
  
        >>> from scipy.sparse import coo_matrix
        >>> X_sparse = coo_matrix(X)
  
        >>> from sklearn.utils import resample
        >>> X, X_sparse, y = resample(X, X_sparse, y, random_state=0)
        >>> X
        array([[ 1.,  0.],
               [ 2.,  1.],
               [ 1.,  0.]])
  
        >>> X_sparse                   # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
        <3x2 sparse matrix of type '<... 'numpy.float64'>'
            with 4 stored elements in Compressed Sparse Row format>
  
        >>> X_sparse.toarray()
        array([[ 1.,  0.],
               [ 2.,  1.],
               [ 1.,  0.]])
  
        >>> y
        array([0, 1, 0])
  
        >>> resample(y, n_samples=2, random_state=0)
        array([0, 1])
  
  
      See also
      --------
      :func:`sklearn.utils.shuffle`
      """
      random_state = check_random_state(
          options.pop("random_state", None)
      )
      replace = options.pop("replace", True)
      max_n_samples = options.pop("n_samples", None)
      if options:
          raise ValueError(
              "Unexpected kw arguments: %r" % options.keys()
          )
  
      if len(arrays) == 0:
          return None
  
      first = arrays[0]
      n_samples = (
          first.shape[0] if hasattr(first, "shape") else len(first)
      )
  
      if max_n_samples is None:
          max_n_samples = n_samples
      elif (max_n_samples > n_samples) and (not replace):
          raise ValueError(
              "Cannot sample %d out of arrays with dim %d"
              "when replace is False" % (max_n_samples, n_samples)
          )
  
      check_consistent_length(*arrays)
  
      if replace:
          indices = random_state.randint(
              0, n_samples, size=(max_n_samples,)
          )
      else:
          indices = np.arange(n_samples)
          random_state.shuffle(indices)
          indices = indices[:max_n_samples]
  
      # convert sparse matrices to CSR for row-based indexing
      arrays = [a.tocsr() if issparse(a) else a for a in arrays]
      resampled_arrays = [safe_indexing(a, indices) for a in arrays]
      if len(resampled_arrays) == 1:
          # syntactic sugar for the unit argument case
          return resampled_arrays[0]
      else:
          return resampled_arrays
  
imports: from collections import Sequence
  import numpy
  from scipy.sparse import issparse
  import warnings
  from .murmurhash import murmurhash3_32
  from .validation import as_float_array, assert_all_finite, check_random_state, column_or_1d, check_array, check_consistent_length, check_X_y, indexable, check_symmetric
  from .deprecation import deprecated
  from .class_weight import compute_class_weight, compute_sample_weight
  from ..externals.joblib import cpu_count
  from ..exceptions import ConvergenceWarning
  from ..exceptions import DataConversionWarning
label_desc: Use image node_id 4 for calling a global function with example usage: resample() and returns: None, resampled_arrays, resampled_arrays