An IEEE half-float implementation in python similar to array.array, is there any way I could make this more efficient?

• Add PEP484 type hints
• In your to_h and to_v, consider tuple-unpacking the return value from struct to get a free assertion that there is only one item
• NotImplemented is not a very friendly way to handle comparison of disparate types. I would far sooner expect return False.
• Move your testing code into a function to avoid namespace pollution
• Single-quotes are not standard for docstrings; use triple quotes instead
• your __repr__ was broken and used __name where it needed __name__
• Have you considered replacing most of this with a Numpy half-precision array created via frombuffer?

Suggested

import struct
from collections.abc import Sequence
from typing import Union, Any, Iterable, Optional


class Float16Array(Sequence):
    """
    Takes a bytes or bytearray object and interprets it as an array of
    16-bit IEEE half-floats

    Behaves a bit like if you could create an array.array('e', [1, 2, 3.7])
    """
    def __init__(self, buf: bytes):
        self.hbuf = memoryview(buf).cast('H')

    @staticmethod
    def _to_h(v: float) -> int:
        """convert float to an unsigned 16 bit integer representation"""
        i, = struct.unpack('H', struct.pack('e', v))
        return i

    @staticmethod
    def _to_v(h: int) -> float:
        """convert 16-bit integer back to regular float"""
        f, = struct.unpack('e', struct.pack('H', h))
        return f

    def __len__(self) -> int:
        return len(self.hbuf)

    def __eq__(self, other: Any) -> bool:
        if isinstance(other, self.__class__):
            return self.hbuf == other.hbuf

        if not isinstance(other, Sequence):
            return False

        if len(self) != len(other):
            return False

        for hval, oval in zip(self.hbuf, other):
            try:
                if hval != self._to_h(oval):
                    return False
            except struct.error:
                return False

        return True

    def __getitem__(self, key: Union[int, slice]) -> float:
        if isinstance(key, slice):
            return self.__class__(self.hbuf[key].cast('B'))
        item = self.hbuf[key]
        return self._to_v(item)

    def __contains__(self, value: float) -> bool:
        try:
            return self._to_h(value) in self.hbuf
        except struct.error:
            return False

    def __reversed__(self) -> Iterable[float]:
        for item in reversed(self.hbuf):
            yield self._to_v(item)

    def index(self, value: float, start: int = 0, stop: Optional[int] = None) -> int:
        buf = self.hbuf[start:stop]
        try:
            buf_val = self._to_h(value)
        except struct.error:
            raise TypeError('value must be float or int') from None
        for i, v in enumerate(buf):
            if v is buf_val or v == buf_val:
                return i
        raise ValueError

    def count(self, value: Union[float, int]) -> int:
        try:
            buf_val = self._to_h(value)
        except struct.error:
            raise TypeError('value must be float or int') from None
        return sum(1 for v in self.hbuf if v == buf_val)

    def __repr__(self) -> str:
        contents = ', '.join('{:.2f}'.format(v).rstrip('0') for v in self)
        return f'{self.__class__.__name__}({contents})'


def test():
    my_array = Float16Array(struct.pack('eeee', 0.1, 0.1, 72.0, 3.141))
    assert 0.1 in my_array
    assert my_array.count(72) == 1
    assert my_array.count(0.1)
    assert my_array == [0.1, 0.1, 72.0, 3.141]
    print(list(reversed(my_array)))
    print(my_array)
    assert my_array[0:-1] == Float16Array(struct.pack('eee', 0.1, 0.1, 72.0))


if __name__ == '__main__':
    test()

Suggested (numpy)

No custom code; the equivalent test is:

def test_new():
    data = (0.1, 0.1, 72.0, 3.141)
    my_array = np.array(data, dtype=np.float16)
    assert 0.1 in my_array
    assert np.sum(my_array == 72) == 1
    assert np.sum(my_array == 0.1) == 2
    assert np.all(np.isclose(my_array, data, rtol=1e-4, atol=1e-4))
    print(my_array[::-1])
    print(my_array)
    assert np.all(np.isclose(
        my_array[:-1],
        np.array(data[:-1], dtype=np.float16),
    ))