要读取一个文件-一次一个字节(忽略缓冲)-你可以使用双参数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”(空字节串)。对于大文件，内存不会无限增长。你可以将buffering=0传递给open()来禁用缓冲——它保证每次迭代只读取一个字节(慢)。

With-statement自动关闭文件——包括下面的代码引发异常的情况。

尽管默认情况下存在内部缓冲，但一次处理一个字节的效率仍然很低。例如，下面是黑洞.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

在我的机器上，当chunksize == 32768时，它处理大约1.5 GB/s，当chunksize == 1时，它只处理大约7.5 MB/s。也就是说，每次读取一个字节要慢200倍。考虑一下您是否可以重写处理以便一次使用多个字节，以及您是否需要性能。

Mmap允许您同时将文件视为bytearray和文件对象。如果需要访问两个接口，它可以作为在内存中加载整个文件的替代方案。特别是，你可以在一个内存映射文件上一次迭代一个字节，只使用简单的for循环:

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]返回文件中从位置i开始的len字节。Python 3.2之前不支持上下文管理器协议;在这种情况下，需要显式调用mm.close()。使用mmap遍历每个字节比file.read(1)消耗更多的内存，但是mmap要快一个数量级。

在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函数和可调用的哨兵签名(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:
            yield from chunk

注意，我们使用file.read1。文件。read块，直到它得到它或EOF请求的所有字节。文件。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
            yield from chunk

以上只适用于语义上人类可读的文本文件(如纯文本、代码、标记、markdown等)。基本上任何ascii, utf，拉丁语等…编码)，您应该打开没有'b'标志。

总结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.塞巴斯蒂安的解决方案提高速度

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)

如果你正在寻找一些快速的方法，这里有一个我一直在使用的方法，它已经工作了很多年:

from array import array

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

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

如果你想迭代字符而不是整数，你可以简单地使用data = file.read()，它应该是py3中的bytes()对象。

这个生成器从文件中产生字节，以块的形式读取文件:

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)

有关迭代器和生成器的信息，请参阅Python文档。

要读取一个文件-一次一个字节(忽略缓冲)-你可以使用双参数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”(空字节串)。对于大文件，内存不会无限增长。你可以将buffering=0传递给open()来禁用缓冲——它保证每次迭代只读取一个字节(慢)。

With-statement自动关闭文件——包括下面的代码引发异常的情况。

尽管默认情况下存在内部缓冲，但一次处理一个字节的效率仍然很低。例如，下面是黑洞.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

在我的机器上，当chunksize == 32768时，它处理大约1.5 GB/s，当chunksize == 1时，它只处理大约7.5 MB/s。也就是说，每次读取一个字节要慢200倍。考虑一下您是否可以重写处理以便一次使用多个字节，以及您是否需要性能。

Mmap允许您同时将文件视为bytearray和文件对象。如果需要访问两个接口，它可以作为在内存中加载整个文件的替代方案。特别是，你可以在一个内存映射文件上一次迭代一个字节，只使用简单的for循环:

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]返回文件中从位置i开始的len字节。Python 3.2之前不支持上下文管理器协议;在这种情况下，需要显式调用mm.close()。使用mmap遍历每个字节比file.read(1)消耗更多的内存，但是mmap要快一个数量级。