class_docstr: Transforms lists of feature-value mappings to vectors.
  
  This transformer turns lists of mappings (dict-like objects) of feature
  names to feature values into Numpy arrays or scipy.sparse matrices for use
  with scikit-learn estimators.
  
  When feature values are strings, this transformer will do a binary one-hot
  (aka one-of-K) coding: one boolean-valued feature is constructed for each
  of the possible string values that the feature can take on. For instance,
  a feature "f" that can take on the values "ham" and "spam" will become two
  features in the output, one signifying "f=ham", the other "f=spam".
  
  However, note that this transformer will only do a binary one-hot encoding
  when feature values are of type string. If categorical features are
  represented as numeric values such as int, the DictVectorizer can be
  followed by OneHotEncoder to complete binary one-hot encoding.
  
  Features that do not occur in a sample (mapping) will have a zero value
  in the resulting array/matrix.
  
  Read more in the :ref:`User Guide <dict_feature_extraction>`.
  
  Parameters
  ----------
  dtype : callable, optional
      The type of feature values. Passed to Numpy array/scipy.sparse matrix
      constructors as the dtype argument.
  separator : string, optional
      Separator string used when constructing new features for one-hot
      coding.
  sparse : boolean, optional.
      Whether transform should produce scipy.sparse matrices.
      True by default.
  sort : boolean, optional.
      Whether ``feature_names_`` and ``vocabulary_`` should be sorted when fitting.
      True by default.
  
  Attributes
  ----------
  vocabulary_ : dict
      A dictionary mapping feature names to feature indices.
  
  feature_names_ : list
      A list of length n_features containing the feature names (e.g., "f=ham"
      and "f=spam").
  
  Examples
  --------
  >>> from sklearn.feature_extraction import DictVectorizer
  >>> v = DictVectorizer(sparse=False)
  >>> D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
  >>> X = v.fit_transform(D)
  >>> X
  array([[ 2.,  0.,  1.],
         [ 0.,  1.,  3.]])
  >>> v.inverse_transform(X) ==         [{'bar': 2.0, 'foo': 1.0}, {'baz': 1.0, 'foo': 3.0}]
  True
  >>> v.transform({'foo': 4, 'unseen_feature': 3})
  array([[ 0.,  0.,  4.]])
  
  See also
  --------
  FeatureHasher : performs vectorization using only a hash function.
  sklearn.preprocessing.OneHotEncoder : handles nominal/categorical features
    encoded as columns of integers.
code: def _transform(self, X, fitting):
      # Sanity check: Python's array has no way of explicitly requesting the
      # signed 32-bit integers that scipy.sparse needs, so we use the next
      # best thing: typecode "i" (int). However, if that gives larger or
      # smaller integers than 32-bit ones, np.frombuffer screws up.
      assert array("i").itemsize == 4, (
          "sizeof(int) != 4 on your platform; please report this at"
          " https://github.com/scikit-learn/scikit-learn/issues and"
          " include the output from platform.platform() in your bug report"
      )
  
      dtype = self.dtype
      if fitting:
          feature_names = []
          vocab = {}
      else:
          feature_names = self.feature_names_
          vocab = self.vocabulary_
  
      # Process everything as sparse regardless of setting
      X = [X] if isinstance(X, Mapping) else X
  
      indices = array("i")
      indptr = array("i", [0])
      # XXX we could change values to an array.array as well, but it
      # would require (heuristic) conversion of dtype to typecode...
      values = []
  
      # collect all the possible feature names and build sparse matrix at
      # same time
      for x in X:
          for f, v in six.iteritems(x):
              if isinstance(v, six.string_types):
                  f = "%s%s%s" % (f, self.separator, v)
                  v = 1
              if f in vocab:
                  indices.append(vocab[f])
                  values.append(dtype(v))
              else:
                  if fitting:
                      feature_names.append(f)
                      vocab[f] = len(vocab)
                      indices.append(vocab[f])
                      values.append(dtype(v))
  
          indptr.append(len(indices))
  
      if len(indptr) == 1:
          raise ValueError("Sample sequence X is empty.")
  
      indices = frombuffer_empty(indices, dtype=np.intc)
      indptr = np.frombuffer(indptr, dtype=np.intc)
      shape = (len(indptr) - 1, len(vocab))
  
      result_matrix = sp.csr_matrix(
          (values, indices, indptr), shape=shape, dtype=dtype
      )
  
      # Sort everything if asked
      if fitting and self.sort:
          feature_names.sort()
          map_index = np.empty(len(feature_names), dtype=np.int32)
          for new_val, f in enumerate(feature_names):
              map_index[new_val] = vocab[f]
              vocab[f] = new_val
          result_matrix = result_matrix[:, map_index]
  
      if self.sparse:
          result_matrix.sort_indices()
      else:
          result_matrix = result_matrix.toarray()
  
      if fitting:
          self.feature_names_ = feature_names
          self.vocabulary_ = vocab
  
      return result_matrix
  
imports: from array import array
  from collections import Mapping
  from operator import itemgetter
  import numpy
  import scipy.sparse
  from ..base import BaseEstimator, TransformerMixin
  from ..externals import six
  from ..externals.six.moves import xrange
  from ..utils import check_array, tosequence
  from ..utils.fixes import frombuffer_empty
label_desc: Use image node_id 3 for calling the DictVectorizer obj's underlying member method code with example usage: obj._transform(X, fitting) and returns: result_matrix