Python binaire EOF

Pour citer le la documentation:

file.read([size])

Lire au plus taille en octets du fichier (moins si la lecture hits EOF avant d'obtenir la taille en octets). Si la taille de l'argument est négatif ou omis, la lecture de toutes les données jusqu'à ce que EOF est atteint. Les octets sont retournés comme un objet de type string. Une chaîne vide est renvoyée lorsque EOF est rencontré immédiatement. (Pour certains fichiers, comme l'ats, il est logique de continuer la lecture après une EOF est atteint.) Notez que cette méthode peut appeler le sous-jacent C de la fonction fread() plus d'une fois, dans un effort pour acquérir près de la taille octets que possible. Notez également qu'en cas de non-blocage de mode, moins de données que ce qui était demandé peut être renvoyé, même si aucun paramètre de taille a été donné.

Qui signifie (pour un un fichier régulier):

• f.read(1) sera de retour un octet objet contenant soit 1 octet 0 octet est EOF a été atteint
• f.read(2) sera de retour un octet objet contenant soit 2 octets, soit 1 octet si EOF est atteint après le premier octet, ou de 0 octet si EOF en a rencontré immédiatement.
• ...

Si vous souhaitez lire votre fichier d'un octet à la fois, vous aurez à read(1) dans une boucle et test du "vide" du résultat:

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

Si vous souhaitez lire votre fichier par "morceau" de dire 50 octets à la fois, vous aurez à read(50) dans une boucle:

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

En fait, on peut même casser une itération plus tôt:

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

---

Concernant l'autre partie de votre question:

Pourquoi le conteneur [..] contient [..] tout un tas d'entre eux [octets]?

Se référant à ce code:

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

Pour citer de nouveau le le doc:

Un fichier objet est sa propre itérateur, [..]. Lorsqu'un fichier est utilisé comme un itérateur, généralement dans une boucle for (par exemple, pour la ligne à f: ligne d'impression.strip()), la méthode next() est appelée à plusieurs reprises. Cette méthode renvoie le à côté de l'entrée de la ligne, ou soulève StopIteration lorsque EOF est atteint lorsque le fichier est ouvert en lecture (comportement n'est pas défini lorsque le fichier est ouvert en écriture).

Le code ci-dessus lire un fichier binaire ligne par ligne. C'est en s'arrêtant à chaque occurrence de l'EOL char (\n). Habituellement, cela conduit à des segments de différentes longueurs comme la plupart des fichiers binaires contenant les occurrences de ce char distribués de façon aléatoire.

Je ne voudrais pas vous encourageons à lire un fichier binaire de cette façon. Merci de préférer l'un à une solution basée sur read(size).

OriginalL'auteur Sylvain Leroux

Lire octet par octet:

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

OriginalL'auteur Daniel