Чтение двоичного файла и цикл по каждому байту

В Python, как я читаю в двоичном файле и петлю над каждым байтом этого файла?

282
24 июня '09 в 0:26
источник поделиться
9 ответов
f = open("myfile", "rb")
try:
    byte = f.read(1)
    while byte != "":
        # Do stuff with byte.
        byte = f.read(1)
finally:
    f.close()

По предложению chrispy:

with open("myfile", "rb") as f:
    byte = f.read(1)
    while byte != "":
        # Do stuff with byte.
        byte = f.read(1)

Обратите внимание, что оператор with не доступен в версиях Python ниже 2.5. Чтобы использовать его в версии 2.5, вам необходимо импортировать его:

from __future__ import with_statement

В 2.6 это не требуется.

В Python 3 это немного отличается. Мы больше не будем получать сырые символы из потока в байтовом режиме, кроме байт-объектов, поэтому нам нужно изменить условие:

with open("myfile", "rb") as f:
    byte = f.read(1)
    while byte != b"":
        # Do stuff with byte.
        byte = f.read(1)

Или, как говорит benhoyt, пропустите не равное и воспользуйтесь тем, что b"" оценивается как false. Это делает код совместимым между 2.6 и 3.x без каких-либо изменений. Это также избавит вас от изменения условия, если вы переходите из режима байта в текст или наоборот.

with open("myfile", "rb") as f:
    byte = f.read(1)
    while byte:
        # Do stuff with byte.
        byte = f.read(1)
290
24 июня '09 в 0:31
источник

Этот генератор дает байты из файла, считывая файл в кусках:

def bytes_from_file(filename, chunksize=8192):
    with open(filename, "rb") as f:
        while True:
            chunk = f.read(chunksize)
            if chunk:
                for b in chunk:
                    yield b
            else:
                break

# example:
for b in bytes_from_file('filename'):
    do_stuff_with(b)

Информацию о iterators и .

137
24 июня '09 в 0:50
источник

Если файл не слишком большой, что проблема с хранением в памяти - это проблема:

bytes_read = open("filename", "rb").read()
for b in bytes_read:
    process_byte(b)

где process_byte представляет некоторую операцию, которую вы хотите выполнить на байте с передачей.

Если вы хотите обработать фрагмент за раз:

file = open("filename", "rb")
try:
    bytes_read = file.read(CHUNKSIZE)
    while bytes_read:
        for b in bytes_read:
            process_byte(b)
        bytes_read = file.read(CHUNKSIZE)
finally:
    file.close()
43
24 июня '09 в 0:43
источник

Для чтения файла - по одному байту за раз (без учета буферизации) - вы можете использовать встроенную функцию two-argument iter(callable, sentinel):

with open(filename, 'rb') as file:
    for byte in iter(lambda: file.read(1), b''):
        # Do stuff with byte

Он вызывает file.read(1), пока не вернет ничего b'' (пустая bytestring). Для больших файлов память не увеличивается неограниченно. Вы можете передать buffering=0 в open(), чтобы отключить буферизацию - это гарантирует, что на каждую итерацию (медленную) считывается только один байт.

with -statement автоматически закрывает файл - включая случай, когда код под ним вызывает исключение.

Несмотря на наличие внутренней буферизации по умолчанию, все равно неэффективно обрабатывать один байт за раз. Например, здесь утилита blackhole.py, которая ест все, что ей дано:

#!/usr/bin/env python3
"""Discard all input. `cat > /dev/null` analog."""
import sys
from functools import partial
from collections import deque

chunksize = int(sys.argv[1]) if len(sys.argv) > 1 else (1 << 15)
deque(iter(partial(sys.stdin.detach().read, chunksize), b''), maxlen=0)

Пример:

$ dd if=/dev/zero bs=1M count=1000 | python3 blackhole.py

Он обрабатывает ~ 1.5 GB/s, когда chunksize == 32768 на моей машине и только ~ 7.5 MB/s, когда chunksize == 1. То есть, в 200 раз медленнее читать по одному байту за раз. Учитывайте это, если вы можете переписать свою обработку для использования более одного байта за раз, и если вам нужна производительность.

mmap позволяет обрабатывать файл как bytearray и объект файла одновременно. Он может служить альтернативой загрузке всего файла в память, если вам нужен доступ к обоим интерфейсам. В частности, вы можете перебирать один байт за один раз над файлом с отображением памяти, используя простой for -loop:

from mmap import ACCESS_READ, mmap

with open(filename, 'rb', 0) as f, mmap(f.fileno(), 0, access=ACCESS_READ) as s:
    for byte in s: # length is equal to the current file size
        # Do stuff with byte

mmap поддерживает нотацию среза. Например, mm[i:i+len] возвращает len байты из файла, начинающегося с позиции i. Протокол менеджера контекста не поддерживается до Python 3.2; вам нужно явно вызвать mm.close() в этом случае. Итерация по каждому байту с использованием mmap потребляет больше памяти, чем file.read(1), но mmap на порядок быстрее.

26
16 нояб. '13 в 7:47
источник

Подводя итог всем блестящим пунктам Chrispy, Skurmedel, Ben Hoyt и Peter Hansen, это было бы оптимальным решением для обработки двоичного файла по одному байту за раз:

with open("myfile", "rb") as f:
    while True:
        byte = f.read(1)
        if not byte:
            break
        do_stuff_with(ord(byte))

Для версий python 2.6 и выше, потому что:

  • буферы python внутри - не нужно читать фрагменты
  • Принцип DRY - не повторяйте строку чтения
  • с инструкцией обеспечивает закрытие файла
  • 'byte' вычисляет значение false, когда больше нет байтов (не тогда, когда байт равен нулю)

Или используйте решение J. F. Sebastians для улучшения скорости

from functools import partial

with open(filename, 'rb') as file:
    for byte in iter(partial(file.read, 1), b''):
        # Do stuff with byte

Или, если вы хотите, чтобы это была функция генератора, показанная с помощью codeape:

def bytes_from_file(filename):
    with open(filename, "rb") as f:
        while True:
            byte = f.read(1)
            if not byte:
                break
            yield(ord(byte))

# example:
for b in bytes_from_file('filename'):
    do_stuff_with(b)
18
06 сент. '13 в 10:55
источник

Чтение двоичного файла в Python и цикл по каждому байту

Новый в Python 3.5 является модулем pathlib, который имеет метод удобства, специально предназначенный для чтения в файле в виде байтов, что позволяет нам перебирать байты. Я считаю, что это достойный (если быстрый и грязный) ответ:

import pathlib

for byte in pathlib.Path(path).read_bytes():
    print(byte)

Интересно, что это единственный ответ, чтобы упомянуть pathlib.

В Python 2 вы, вероятно, сделаете это (как предлагает Vinay Sajip):

with open(path, 'b') as file:
    for byte in file.read():
        print(byte)

В случае, если файл может быть слишком большим, чтобы перебирать его в памяти, вы должны его обманывать, идиоматически, используя функцию iter с подписью callable, sentinel - версию Python 2:

with open(path, 'b') as file:
    callable = lambda: file.read(1024)
    sentinel = bytes() # or b''
    for chunk in iter(callable, sentinel): 
        for byte in chunk:
            print(byte)

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

Лучшая практика для больших файлов или буферизованное/интерактивное чтение

Позвольте создать функцию для этого, включая идиоматические использования стандартной библиотеки для Python 3.5 +:

from pathlib import Path
from functools import partial
from io import DEFAULT_BUFFER_SIZE

def file_byte_iterator(path):
    """given a path, return an iterator over the file
    that lazily loads the file
    """
    path = Path(path)
    with path.open('rb') as file:
        reader = partial(file.read1, DEFAULT_BUFFER_SIZE)
        file_iterator = iter(reader, bytes())
        for chunk in file_iterator:
            for byte in chunk:
                yield byte

Обратите внимание, что мы используем file.read1. file.read блокирует, пока не получит все запрошенные байты, или EOF. file.read1 позволяет избежать блокировки, и из-за этого он может быстрее вернуться. Никакие другие ответы не упоминают об этом.

Демонстрация использования наилучшей практики:

Сделайте файл с мегабайтом (фактически mebibyte) псевдослучайных данных:

import random
import pathlib
path = 'pseudorandom_bytes'
pathobj = pathlib.Path(path)

pathobj.write_bytes(
  bytes(random.randint(0, 255) for _ in range(2**20)))

Теперь перейдем к ней и материализуем ее в памяти:

>>> l = list(file_byte_iterator(path))
>>> len(l)
1048576

Мы можем проверять любую часть данных, например, последние 100 и первые 100 байтов:

>>> l[-100:]
[208, 5, 156, 186, 58, 107, 24, 12, 75, 15, 1, 252, 216, 183, 235, 6, 136, 50, 222, 218, 7, 65, 234, 129, 240, 195, 165, 215, 245, 201, 222, 95, 87, 71, 232, 235, 36, 224, 190, 185, 12, 40, 131, 54, 79, 93, 210, 6, 154, 184, 82, 222, 80, 141, 117, 110, 254, 82, 29, 166, 91, 42, 232, 72, 231, 235, 33, 180, 238, 29, 61, 250, 38, 86, 120, 38, 49, 141, 17, 190, 191, 107, 95, 223, 222, 162, 116, 153, 232, 85, 100, 97, 41, 61, 219, 233, 237, 55, 246, 181]
>>> l[:100]
[28, 172, 79, 126, 36, 99, 103, 191, 146, 225, 24, 48, 113, 187, 48, 185, 31, 142, 216, 187, 27, 146, 215, 61, 111, 218, 171, 4, 160, 250, 110, 51, 128, 106, 3, 10, 116, 123, 128, 31, 73, 152, 58, 49, 184, 223, 17, 176, 166, 195, 6, 35, 206, 206, 39, 231, 89, 249, 21, 112, 168, 4, 88, 169, 215, 132, 255, 168, 129, 127, 60, 252, 244, 160, 80, 155, 246, 147, 234, 227, 157, 137, 101, 84, 115, 103, 77, 44, 84, 134, 140, 77, 224, 176, 242, 254, 171, 115, 193, 29]

Не выполнять итерацию по строкам для двоичных файлов

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

    with open(path, 'rb') as file:
        for chunk in file: # text newline iteration - not for bytes
            for byte in chunk:
                yield byte

Вышеприведенное только полезно для семантически понятных для чтения текстовых файлов (таких как простой текст, код, разметка, уценка и т.д.... по существу, любые ascii, utf, latin и т.д.).

9
14 мая '16 в 7:16
источник

Python 3, сразу прочитайте весь файл:

with open("filename", "rb") as binary_file:
    # Read the whole file at once
    data = binary_file.read()
    print(data)

Вы можете перебирать все, что хотите, используя переменную data.

2
25 сент. '16 в 8:26
источник

Если у вас есть много двоичных данных для чтения, вам может потребоваться рассмотреть struct module. Он документируется как преобразование "между типами C и Python", но, конечно, байты являются байтами, и независимо от того, были ли они созданы как типы C, не имеет значения. Например, если ваши двоичные данные содержат два целых 2 байта и одно целое число из 4 байтов, вы можете прочитать их следующим образом (пример взято из документации struct):

>>> struct.unpack('hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
(1, 2, 3)

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

1
01 июля '15 в 14:24
источник

если вы ищете что-то быстрое, здесь метод, который я использовал, работал много лет:

from array import array

with open( path, 'rb' ) as file:
    data = array( 'B', file.read() ) # buffer the file

# evaluate it data
for byte in data:
    v = byte # int value
    c = chr(byte)

если вы хотите итерации символов вместо ints, вы можете просто использовать data = file.read(), который должен быть объектом bytes() в py3.

0
22 сент. '15 в 18:20
источник

Посмотрите другие вопросы по меткам или Задайте вопрос