Python File Slurp с обратным преобразованием

Question

Недавно спросили , как сделать файл slurp в python , и принятый ответ предложил что-то вроде:

with open('x.txt') as x: f = x.read()

Как мне поступить так, чтобы прочитать файл и преобразовать представление данных в порядке байтов?

Например, у меня есть бинарный файл размером 1 ГБ, который представляет собой просто набор чисел с плавающей точкой одинарной точности, упакованный в формате с прямым порядком байтов, и я хочу преобразовать его в формат с прямым порядком байтов и вывести в массив с пустыми данными. Ниже приведена функция, которую я написал для выполнения этого и некоторый реальный код, который ее вызывает. Я использую struct.unpack, выполняю преобразование в порядке байтов и пытался ускорить все, используя mmap.

Мой вопрос: правильно ли я использую приманку с mmap и struct.unpack? Есть ли более чистый и быстрый способ сделать это? Сейчас то, что у меня работает, но я бы очень хотел узнать, как это сделать лучше.

Заранее спасибо!

#!/usr/bin/python
from struct import unpack
import mmap
import numpy as np

def mmapChannel(arrayName,  fileName,  channelNo,  line_count,  sample_count):
    """
    We need to read in the asf internal file and convert it into a numpy array.
    It is stored as a single row, and is binary. Thenumber of lines (rows), samples (columns),
    and channels all come from the .meta text file
    Also, internal format files are packed big endian, but most systems use little endian, so we need
    to make that conversion as well.
    Memory mapping seemed to improve the ingestion speed a bit
    """
    # memory-map the file, size 0 means whole file
    # length = line_count * sample_count * arrayName.itemsize
    print "\tMemory Mapping..."
    with open(fileName, "rb") as f:
        map = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
        map.seek(channelNo*line_count*sample_count*arrayName.itemsize)

        for i in xrange(line_count*sample_count):
            arrayName[0, i] = unpack('>f', map.read(arrayName.itemsize) )[0]

        # Same method as above, just more verbose for the maintenance programmer.
        #        for i in xrange(line_count*sample_count): #row
        #            be_float = map.read(arrayName.itemsize) # arrayName.itemsize should be 4 for float32
        #            le_float = unpack('>f', be_float)[0] # > for big endian, < for little endian
        #            arrayName[0, i]= le_float

        map.close()
    return arrayName

print "Initializing the Amp HH HV, and Phase HH HV arrays..."
HHamp = np.ones((1,  line_count*sample_count),  dtype='float32')
HHphase = np.ones((1,  line_count*sample_count),  dtype='float32')
HVamp = np.ones((1,  line_count*sample_count),  dtype='float32')
HVphase = np.ones((1,  line_count*sample_count),  dtype='float32')



print "Ingesting HH_Amp..."
HHamp = mmapChannel(HHamp, 'ALPSRP042301700-P1.1__A.img',  0,  line_count,  sample_count)
print "Ingesting HH_phase..."
HHphase = mmapChannel(HHphase, 'ALPSRP042301700-P1.1__A.img',  1,  line_count,  sample_count)
print "Ingesting HV_AMP..."
HVamp = mmapChannel(HVamp, 'ALPSRP042301700-P1.1__A.img',  2,  line_count,  sample_count)
print "Ingesting HV_phase..."
HVphase = mmapChannel(HVphase, 'ALPSRP042301700-P1.1__A.img',  3,  line_count,  sample_count)

print "Reshaping...."
HHamp_orig = HHamp.reshape(line_count, -1)
HHphase_orig = HHphase.reshape(line_count, -1)
HVamp_orig = HVamp.reshape(line_count, -1)
HVphase_orig = HVphase.reshape(line_count, -1)

Answer 1

Слегка измененный @ ответ Алекса Мартелли :

arr = numpy.fromfile(filename, numpy.dtype('>f4'))
# no byteswap is needed regardless of endianess of the machine

Answer 2

with open(fileName, "rb") as f:
  arrayName = numpy.fromfile(f, numpy.float32)
arrayName.byteswap(True)

Довольно сложно победить за скорость и краткость ;-). Об изменении байтов см. здесь (аргумент True означает «сделай это на месте»); для fromfile см. здесь .

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

if struct.pack('=f', 2.3) == struct.pack('<f', 2.3):
  arrayName.byteswap(True)

То есть, вызов byteswap обусловлен проверкой порядка байтов.

Answer 3

Я бы ожидал, что что-то вроде этого будет быстрее

arrayName[0] = unpack('>'+'f'*line_count*sample_count, map.read(arrayName.itemsize*line_count*sample_count))

Пожалуйста, не используйте map в качестве имени переменной

Answer 4

Вы можете объединить решение ASM , используя CorePy . Интересно, если бы вы могли получить достаточно производительности от какой-то другой части вашего алгоритма. Операции ввода-вывода и манипуляции с кусками данных объемом 1 ГБ будут занимать какое-то время, как бы вы их ни вырезали.

Еще одна вещь, которую вы могли бы найти полезной, это переключиться на C после того, как вы создали прототип алгоритма в python. Я сделал это для манипуляций с набором данных DEM (высота) всего мира один раз. Все это стало гораздо более терпимым, когда я ушел от интерпретированного сценария.