class_docstr: Create a molecule object that stores molecular information and default basis set parameters.
  
  The molecule object can be passed to functions that perform a Hartree-Fock calculation.
  
  Args:
      symbols (list[str]): Symbols of the atomic species in the molecule. Currently, atoms with
          atomic numbers 1-10 are supported.
      coordinates (array[float]): 1D array with the atomic positions in Cartesian coordinates. The
          coordinates must be given in atomic units and the size of the array should be ``3*N``
          where ``N`` is the number of atoms.
      charge (int): net charge of the molecule
      mult (int): Spin multiplicity :math:`\mathrm{mult}=N_\mathrm{unpaired} + 1` for
          :math:`N_\mathrm{unpaired}` unpaired electrons occupying the HF orbitals. Currently,
          openshell systems are not supported; ``mult`` must be equal to :math:`1`.
      basis_name (str): Atomic basis set used to represent the molecular orbitals. Currently, the
          only supported basis sets are 'STO-3G', '6-31G', '6-311G' and 'CC-PVDZ'.
      load_data (bool): flag to load data from the basis-set-exchange library
      l (tuple[int]): angular momentum quantum numbers of the basis function
      alpha (array[float]): exponents of the primitive Gaussian functions
      coeff (array[float]): coefficients of the contracted Gaussian functions
      r (array[float]): positions of the Gaussian functions
      normalize (bool): if True, the basis functions get normalized
  
  **Example**
  
  >>> symbols  = ['H', 'H']
  >>> geometry = np.array([[0.0, 0.0, -0.694349],
  >>>                      [0.0, 0.0,  0.694349]], requires_grad = True)
  >>> mol = Molecule(symbols, geometry)
  >>> print(mol.n_electrons)
  2
docstr: Returns the molecule representation in string format
docstr_tok: ["Returns","the","molecule","representation","in","string","format"]
code: def __repr__(self):
      """Returns the molecule representation in string format"""
  
      elements, counter, flags = (
          set(self.symbols),
          collections.Counter(self.symbols),
          [],
      )
      if counter["C"]:  # Hill Notation
          flags = ["C", "H"] if counter["H"] else ["C"]
      ordered_elems = flags + list(
          sorted(elements.difference(set(flags)))
      )
      formula = "".join(
          [
              x + str(counter[x]) if counter[x] > 1 else x
              for x in ordered_elems
          ]
      )
  
      return f"<Molecule = {formula}, Charge: {self.charge}, Basis: {self.basis_name.upper()}, Orbitals: {self.n_orbitals}, Electrons: {self.n_electrons}>"
  
file_path: pennylane/pennylane/qchem/molecule.py
imports: import itertools
  import collections
  from pennylane import numpy
  from .basis_data import atomic_numbers
  from .basis_set import BasisFunction, mol_basis_data
  from .integrals import contracted_norm, primitive_norm
label_desc: Use image node_id 2 for calling the Molecule obj's underlying member method code with example usage: obj.__repr__() and returns: str, formula, str, self, str, self, str, self, str, self, str