Element

def __eq__(self, other):
    """Check if two Elements have the same atomic number."""
    if not self._is_valid_operand(other):
        raise NotImplementedError
    return self.atomic_number == other.atomic_number

def _ge_from_lt(self, other, NotImplemented=NotImplemented):
    'Return a >= b.  Computed by @total_ordering from (not a < b).'
    op_result = self.__lt__(other)
    if op_result is NotImplemented:
        return op_result
    return not op_result

def _gt_from_lt(self, other, NotImplemented=NotImplemented):
    'Return a > b.  Computed by @total_ordering from (not a < b) and (a != b).'
    op_result = self.__lt__(other)
    if op_result is NotImplemented:
        return op_result
    return not op_result and self != other

def __hash__(self):
    """Hash of this element (its atomic number)."""
    return int(self.atomic_number)

def __init__(self, atomic_number, name, symbol, cov, vdw, mass):
    """Initialize an Element from its chemical data."""
    self.atomic_number = atomic_number
    self.name = name
    self.symbol = symbol
    self.cov = cov
    self.vdw = vdw
    self.mass = mass

def _le_from_lt(self, other, NotImplemented=NotImplemented):
    'Return a <= b.  Computed by @total_ordering from (a < b) or (a == b).'
    op_result = self.__lt__(other)
    return op_result or self == other

def __lt__(self, other):
    """Check which element comes before the other in chemical formulae (C first, then order of atomic number)."""
    if not self._is_valid_operand(other):
        raise NotImplementedError
    n1, n2 = self.atomic_number, other.atomic_number
    if n1 == n2:
        return False
    if n1 == 6:
        return True
    elif n2 == 6:
        return False
    else:
        return n1 < n2

def __repr__(self):
    """Represent this element as a string for REPL."""
    return self.symbol

@staticmethod
def from_atomic_number(n: int) -> "Element":
    """Create an element from a given atomic number.

    Args:
        n (int): the atomic number of the element

    Returns:
        Element: an Element object if atomic number was valid, otherwise an exception is raised

    Examples:
        >>> Element.from_atomic_number(2)
        He
        >>> Element[79].name
        'gold'
    """
    return Element(n, *_ELEMENT_DATA[n - 1])

@staticmethod
def from_label(label: str) -> "Element":
    """Create an element from a label e.g. 'C1', 'H2_F2___i' etc.

    Args:
        l (str): a string representation of an element in the periodic table

    Returns:
        Element: an Element object if the conversion was successful, otherwise an exception is raised

    Examples:
        >>> Element.from_label("C1")
        C
        >>> Element.from_label("H")
        H
        >>> Element["LI2_F2____1____i"]
        Li

        An ambiguous case, will make this Calcium not Carbon
        >>> Element.from_label("Ca2_F2____1____i")
        Ca
    """
    m = re.match(_SYMBOL_REGEX, label)
    if m is None:
        raise ValueError("Could not determine symbol from {}".format(label))
    sym = m.group(1).strip().capitalize()
    if sym not in _EL_FROM_SYM:
        raise ValueError("Could not determine symbol from {}".format(label))
    return Element(*_EL_FROM_SYM[sym])

@staticmethod
def from_string(s: str) -> "Element":
    """Create an element from a given element symbol.

    Args:
        s (str): a string representation of an element in the periodic table

    Returns:
        Element: an Element object if the conversion was successful, otherwise an exception is raised

    Examples:
        >>> Element.from_string("h")
        H
        >>> Element["rn"].name
        'radon'
        >>> Element["AC"].cov
        2.15
    """
    symbol = s.strip().capitalize()
    if symbol == "D":
        symbol = "H"
    if symbol.isdigit():
        return Element.from_atomic_number(int(symbol))
    if symbol not in _EL_FROM_SYM:
        name = symbol.lower()
        if name not in _EL_FROM_NAME:
            return Element.from_label(s)
        else:
            return Element(*_EL_FROM_NAME[name])
    return Element(*_EL_FROM_SYM[symbol])