Python binario EOF

Voglio leggere un file binario.
Googling “python binario eof” mi ha portato qui.

Ora, le domande:

  1. Perché il contenitore (x in MODO da rispondere) non contengono un singolo (corrente) di byte, ma un intero gruppo? Che cosa sto facendo di sbagliato?
  2. Se deve essere così e sto facendo niente di male, COME non leggere un singolo byte? Voglio dire, c’è un modo per rilevare EOF durante la lettura del file con read(1) metodo?
Non so perché non posso innocuo ottenere un piccolo aiuto da parte della comunità? Perché le domande che non meritano un 5-pagina di risposta, una pagina wiki, o un luogo, nella splendida hall of fame per i grandi sarà SEMPRE downvoted? Perché dovrei chiedere solo su rocket-scienza?
Se non siete soddisfatti del modo in cui si domanda sono percepiti qui, un commento in non la reazione appropriata come downvoter è andato molto tempo fa, e non sarà probabilmente leggere questo commento. Ma altri popoli. Se davvero sono d’accordo e sono assolutamente certo che le vostre domande raggiungere il standard di qualità previsto qui, si potrebbe aumentare il vostro caso meta. Ma essere preparati prima di farlo.

OriginaleL’autore mekkanizer | 2014-08-23

3 Replies
  1. 7

    Per citare il documentazione:

    file.read([size])

    Leggere a più dimensione byte dal file (meno se la lettura colpisce EOF prima di ottenere la dimensione in byte). Se la dimensione argomento è negativo o omesso, lettura di tutti i dati fino a EOF è raggiunto. I byte vengono restituiti come un oggetto string. Viene restituita una stringa vuota quando EOF viene rilevato immediatamente. (Per determinati tipi di file, come ttys, ha senso continuare la lettura dopo un EOF è successo.) Nota che questo metodo può chiamare il sottostante C funzione fread() più di una volta nel tentativo di acquisire il più vicino alla dimensione in byte possibile. Nota anche che in modalità non bloccante, meno dati è stato richiesto può essere restituito, anche se nessun parametro di dimensione.

    Che significa (per un file regolare):

    • f.read(1) restituirà un byte oggetto contenente 1 o byte 0 byte è EOF è stato raggiunto
    • f.read(2) restituirà un byte oggetto contenente 2 byte 1 byte se EOF viene raggiunto dopo il primo byte, o 0 byte se EOF in rilevato immediatamente.

    Se si desidera leggere i file di un byte alla volta, si dovrà read(1) in un ciclo e il test per il “vuoto” del risultato:

    # From answer by @Daniel
    with open(filename, 'rb') as f:
        while True:
            b = f.read(1)
            if not b:
                # eof
                break
            do_something(b)

    Se volete leggere il file di “pezzo” di dire di 50 byte alla volta, si dovrà read(50) in un loop:

    with open(filename, 'rb') as f:
        while True:
            b = f.read(50)
            if not b:
                # eof
                break
            do_something(b) # <- be prepared to handle a last chunk of length < 50
                            #    if the file length *is not* a multiple of 50

    In realtà, si può anche rompere una prima iterazione:

    with open(filename, 'rb') as f:
        while True:
            b = f.read(50)
            do_something(b) # <- be prepared to handle a last chunk of size 0
                            #    if the file length *is* a multiple of 50
                            #    (incl. 0 byte-length file!)
                            #    and be prepared to handle a last chunk of length < 50
                            #    if the file length *is not* a multiple of 50
            if len(b) < 50:
                break

    Riguardanti l’altra parte della tua domanda:

    Perché il contenitore [..] contenere [..] un intero gruppo [byte]?

    Riferimento a che codice:

    for x in file:  
       i=i+1  
       print(x)  

    Per citare di nuovo il doc:

    Un file oggetto è proprio iteratore, [..]. Quando un file viene utilizzato come un iteratore, in genere in un ciclo for (ad esempio, per la linea f: riga di stampa.strip ()) () il metodo viene chiamato più volte. Questo metodo restituisce il prossimo ingresso di linea, o solleva StopIteration quando EOF è raggiunto quando il file è aperto in lettura (comportamento è indefinito quando il file viene aperto per la scrittura).

    Il codice qui sopra per leggere un file binario line-by-line. Che è fermarsi ogni occorrenza dell’EOL (\n). Di solito, che porta a blocchi di varia lunghezza, come la maggior parte dei file binari contiene occorrenze del char distribuiti in modo casuale.

    Non vorrei incoraggiarvi a leggere un file binario che modo. Si prega di preferire una soluzione basata su read(size).

    Ci sono così tante risposte chiudere per questo che NON FUNZIONANO! grazie per la pubblicazione di un grande e dettagliata risposta!!!!! Non ho potuto fare il mio progetto senza questa risposta!
    Per il f.leggere(1) esempio: Cosa succede se il vostro flusso di byte ha un byte a zero, allora il test sarebbe uscita presto, prima che lei avesse finito di leggere il file
    In Python, solo vuoto sequenze sono False (docs.python.org/3.1/library/stdtypes.html) E tutto ciò che non è Falso è Vero. Quindi, se la tua stringa di byte contiene \x00, è non vuoto, quindi b"\x00" è Vero. È possibile verificare che in REPL: "T" if b"\x00" else "F"
    Parola al saggio qui, è importante capire che cosa sta succedendo sotto il cofano quando il buffer di file. Ci sono in realtà diversi buffer di oggetti che contengono parti del tamponata file. Vedere qui. Python dovrebbe rendere questo improbabile, ma il classico problema sollevato da questo è che si finisce con una parte del tuo file ancora in una di quelle sottostanti oggetti di buffer quando fatto. Assicurati di svuotare se i dati mancanti.

    OriginaleL’autore Sylvain Leroux

  2. 4

    "" segnalerà la fine del file

    with open(filename, 'rb') as f:
        for ch in iter(lambda: f.read(1),""): # keep calling f.read(1) until end of the data
            print ch

    OriginaleL’autore Padraic Cunningham

  3. 1

    Lettura byte-per-byte:

    with open(filename, 'rb') as f:
        while True:
            b = f.read(1)
            if not b:
                # eof
                break
            do_something(b)
    ma se il file contiene un byte zero, questo finirà presto, prima che il file viene letto completamente
    sbagliato. not '\0' è False. Solo not '' è True.

    OriginaleL’autore Daniel

Lascia un commento