Могу ли я рассматривать файл как список в python?

Если ваши данные чисто числовые, вы можете рассмотреть возможность использования массивов numpy и сохранения данных в формате npy. После сохранения в этом формате вы можете загрузить отображаемый в память файл как:

>>> X = np.load("some-file.npy", mmap_mode = "r")
>>> X[1000:1003]
memmap([4, 5, 6])

Этот доступ будет загружаться непосредственно с диска, не требуя загрузки начальных данных.

На самом деле вы можете сделать это, написав простой класс, я думаю:

class FileWrapper:

    def __init__(self, path, **kwargs):
        self._file = open(path, 'r+', **kwargs)

    def _do_single(self, where, s=None):
        if where >= 0:
            self._seek(where)

        else:
            self._seek(where, 2)

        if s is None:
            return self._read(1)

        else:
            return self._write(s)

    def _do_slice_contiguous(self, start, end, s=None):
        if start is None:
            start = 0

        if end is None:
            end = -1

        self._seek(start)
        if s is None:
            return self._read(end - start)

        else:
            return self._write(s)

    def _do_slice(self, where, s=None):
        if s is None:
            result = []
            for index in where:
                file._seek(index)
                result.append(file.read(1))

            return result

        else:
            for index, char in zip(where, s):
                file._seek(index)
                file._write(char)

            return len(s)

    def __getitem__(self, key):
        if isinstance(key, int):
            return self._do_single(key)

        elif isinstance(key, slice):
            if self._is_contiguous(key):
                return self._do_slice_contiguous(key.start, key.stop)

            else:
                return self._do_slice(self._process_slice(key))

        else:
            raise ValueError('File indices must be ints or slices.')

    def __setitem__(self, key, value):
        if isinstance(key, int):
            return self._do_single(key, value)

        elif isinstance(key, slice):
            if self._is_contiguous(key):
                return self._do_slice_contiguous(key.start, key.stop, value)

            else:
                where = self._process_slice(key)
                if len(where) == len(value):
                    return self._do_slice(where, value)

                else:
                    raise ValueError('Length of slice not equal to length of string to be written.')


    def __del__(self):
        self._file.close()

    def _is_contiguous(self, key):
        return key.step is None or key.step == 1

    def _process_slice(self, key):
        return range(key.start, key.stop, key.step)

    def _read(self, size):
        return self._file.read(size)

    def _seek(self, offset, whence=0):
        return self._file.seek(offset, whence)

    def _write(self, s):
        return self._file.write(s)

Я уверен, что можно было бы сделать много оптимизаций, так как я торопился с этим, но писать было весело.

Это не отвечает на вопрос полностью, потому что он поддерживает произвольный доступ к персонажи, как предполагается, к строкам, которые находятся на более высоком уровне абстракции и более сложны в обработке (поскольку они могут быть переменной длины)