code: def subs(self, *args):
          
          cols = ['x', 'y', 'z']
          out = self.copy()
  
          def get_subs_f(*args):
              def subs_function(x):
                  if hasattr(x, 'subs'):
                      x = x.subs(*args)
                      try:
                          x = float(x)
                      except TypeError:
                          pass
                  return x
              return subs_function
  
          for col in cols:
              if out.loc[:, col].dtype is np.dtype('O'):
                  out.loc[:, col] = out.loc[:, col].map(get_subs_f(*args))
                  try:
                      out.loc[:, col] = out.loc[:, col].astype('f8')
                  except (SystemError, TypeError):
                      pass
          return out
docs: Substitute a symbolic expression in ``['x', 'y', 'z']``
  
          This is a wrapper around the substitution mechanism of
          `sympy <http://docs.sympy.org/latest/tutorial/basic_operations.html>`_.
          Any symbolic expression in the columns
          ``['x', 'y', 'z']`` of ``self`` will be substituted
          with value.
  
          Args:
              symb_expr (sympy expression):
              value :
              perform_checks (bool): If ``perform_checks is True``,
                  it is asserted, that the resulting Zmatrix can be converted
                  to cartesian coordinates.
                  Dummy atoms will be inserted automatically if necessary.
  
          Returns:
              Cartesian: Cartesian with substituted symbolic expressions.
              If all resulting sympy expressions in a column are numbers,
              the column is recasted to 64bit float.