Leggere un file binario con python

Trovo particolarmente difficile leggere file binari con Python. Puoi darmi una mano? Ho bisogno di leggere questo file, che in Fortran 90 è facilmente leggibile

int*4 n_particles, n_groups
real*4 group_id(n_particles)
read (*) n_particles, n_groups
read (*) (group_id(j),j=1,n_particles)

In dettaglio, il formato del file è:

Bytes 1-4 -- The integer 8.
Bytes 5-8 -- The number of particles, N.
Bytes 9-12 -- The number of groups.
Bytes 13-16 -- The integer 8.
Bytes 17-20 -- The integer 4*N.
Next many bytes -- The group ID numbers for all the particles.
Last 4 bytes -- The integer 4*N. 

Come posso leggerlo con Python? Ho provato di tutto ma non ha mai funzionato. C'è qualche possibilità che io possa usare un programma f90 in Python, leggendo questo file binario e quindi salvare i dati che devo usare?

Leggi il contenuto del file binario in questo modo:

with open(fileName, mode='rb') as file: # b is important -> binary
    fileContent = file.read()

quindi "decomprimere" i dati binari utilizzando struct.unpack :

I byte iniziali: struct.unpack("iiiii", fileContent[:20])

Il corpo: ignora i byte dell'intestazione e il byte finale (= 24); La parte restante forma il corpo, per conoscere il numero di byte nel corpo fare una divisione intera per 4; Il quoziente ottenuto viene moltiplicato per la stringa 'i'per creare il formato corretto per il metodo unpack:

struct.unpack("i" * ((len(fileContent) -24) // 4), fileContent[20:-4])

Il byte finale: struct.unpack("i", fileContent[-4:])

In generale, consiglierei di esaminare l'utilizzo del modulo struct di Python per questo. È standard con Python e dovrebbe essere facile tradurre la specifica della tua domanda in una stringa di formattazione adatta a struct.unpack().

Nota che se c'è un riempimento "invisibile" tra / intorno ai campi, dovrai capirlo e includerlo nella unpack()chiamata, altrimenti leggerai i bit sbagliati.

Leggere il contenuto del file per avere qualcosa da scompattare è piuttosto banale:

import struct

data = open("from_fortran.bin", "rb").read()

(eight, N) = struct.unpack("@II", data)

Questo decomprime i primi due campi, supponendo che inizino all'inizio del file (nessun riempimento o dati estranei) e assumendo anche l'ordine dei byte nativo (il @simbolo). La Is nella stringa di formattazione significa "intero senza segno, 32 bit".

È possibile utilizzare numpy.fromfile, che può leggere i dati da file di testo e binari. Dovresti prima costruire un tipo di dati, che rappresenta il tuo formato di file, usando numpy.dtype, e poi leggere questo tipo dal file usando numpy.fromfile.

Per leggere un file binario in un bytesoggetto:

from pathlib import Path
data = Path('/path/to/file').read_bytes()  # Python 3.5+

Per creare un intdai byte 0-3 dei dati:

i = int.from_bytes(data[:4], byteorder='little', signed=False)

Per decomprimere più messaggi intdi posta elettronica dai dati:

import struct
ints = struct.unpack('iiii', data[:16])

• pathlib
• int.from_bytes()
• struct

Anch'io ho trovato Python carente quando si tratta di leggere e scrivere file binari, quindi ho scritto un piccolo modulo (per Python 3.6+).

Con binaryfile faresti qualcosa del genere (immagino, dato che non conosco Fortran):

import binaryfile

def particle_file(f):
    f.array('group_ids')  # Declare group_ids to be an array (so we can use it in a loop)
    f.skip(4)  # Bytes 1-4
    num_particles = f.count('num_particles', 'group_ids', 4)  # Bytes 5-8
    f.int('num_groups', 4)  # Bytes 9-12
    f.skip(8)  # Bytes 13-20
    for i in range(num_particles):
        f.struct('group_ids', '>f')  # 4 bytes x num_particles
    f.skip(4)

with open('myfile.bin', 'rb') as fh:
    result = binaryfile.read(fh, particle_file)
print(result)

Che produce un output come questo:

{
    'group_ids': [(1.0,), (0.0,), (2.0,), (0.0,), (1.0,)],
    '__skipped': [b'\x00\x00\x00\x08', b'\x00\x00\x00\x08\x00\x00\x00\x14', b'\x00\x00\x00\x14'],
    'num_particles': 5,
    'num_groups': 3
}

Ho usato skip () per saltare i dati aggiuntivi aggiunti da Fortran, ma potresti voler aggiungere un'utilità per gestire correttamente i record Fortran. Se lo fai, una richiesta pull sarebbe la benvenuta.

import pickle
f=open("filename.dat","rb")
try:
    while True:
        x=pickle.load(f)
        print x
except EOFError:
    pass
f.close()