code: def byaxis_out(self):
          
          space = self
  
          class FspaceByaxisOut(object):
  
              """Helper class for indexing by output axes."""
  
              def __getitem__(self, indices):
                  """Return ``self[indices]``.
  
                  Parameters
                  ----------
                  indices : index expression
                      Object used to index the output components.
  
                  Returns
                  -------
                  space : `FunctionSpace`
                      The resulting space with same domain and scalar output
                      data type, but indexed output components.
  
                  Raises
                  ------
                  IndexError
                      If this is a space of scalar-valued functions.
                  """
                  try:
                      iter(indices)
                  except TypeError:
                      newshape = space.out_shape[indices]
                  else:
                      newshape = tuple(space.out_shape[int(i)] for i in indices)
  
                  dtype = (space.scalar_out_dtype, newshape)
                  return FunctionSpace(space.domain, out_dtype=dtype)
  
              def __repr__(self):
                  """Return ``repr(self)``."""
                  return repr(space) + '.byaxis_out'
  
          return FspaceByaxisOut()
docs: Object to index along output dimensions.
  
          This is only valid for non-trivial `out_shape`.
  
          Examples
          --------
          Indexing with integers or slices:
  
          >>> domain = odl.IntervalProd(0, 1)
          >>> fspace = odl.FunctionSpace(domain, out_dtype=(float, (2, 3, 4)))
          >>> fspace.byaxis_out[0]
          FunctionSpace(IntervalProd(0.0, 1.0), out_dtype=('float64', (2,)))
          >>> fspace.byaxis_out[1]
          FunctionSpace(IntervalProd(0.0, 1.0), out_dtype=('float64', (3,)))
          >>> fspace.byaxis_out[1:]
          FunctionSpace(IntervalProd(0.0, 1.0), out_dtype=('float64', (3, 4)))
  
          Lists can be used to stack spaces arbitrarily:
  
          >>> fspace.byaxis_out[[2, 1, 2]]
          FunctionSpace(IntervalProd(0.0, 1.0), out_dtype=('float64', (4, 3, 4)))