1

我需要使用 Python 处理大型 bz2 文件（~6G），通过逐行解压缩，使用BZ2File.readline(). 问题是我想知道处理整个文件需要多少时间。

我做了很多搜索，试图获取解压缩文件的实际大小，以便我可以知道即时处理的百分比，从而知道剩余时间，而发现似乎不可能知道解压缩文件的大小无需先解压缩（https://stackoverflow.com/a/12647847/7876675）。

除了解压缩文件需要大量内存之外，解压缩本身也需要很多时间。那么，任何人都可以帮助我即时获得剩余的处理时间吗？

4

3 回答 3

2

您可以根据压缩数据的消耗量来估算剩余时间，而不是根据未压缩数据的产生量来估算剩余时间。如果数据相对同质，结果将大致相同。（如果不是，那么使用输入或输出无论如何都不会给出准确的估计。）

您可以轻松找到压缩文件的大小，并使用到目前为止在压缩数据上花费的时间来估计处理剩余压缩数据的时间。

这是一个使用BZ2Decompress对象一次对输入进行操作的简单示例，显示读取进度（Python 3，从命令行获取文件名）：

# Decompress a bzip2 file, showing progress based on consumed input.

import sys
import os
import bz2
import time

def proc(input):
    """Decompress and process a piece of a compressed stream"""
    dat = dec.decompress(input)
    got = len(dat)
    if got != 0:    # 0 is common -- waiting for a bzip2 block
        # process dat here
        pass
    return got

# Get the size of the compressed bzip2 file.
path = sys.argv[1]
size = os.path.getsize(path)

# Decompress CHUNK bytes at a time.
CHUNK = 16384
totin = 0
totout = 0
prev = -1
dec = bz2.BZ2Decompressor()
start = time.time()
with open(path, 'rb') as f:
    for chunk in iter(lambda: f.read(CHUNK), b''):
        # feed chunk to decompressor
        got = proc(chunk)

        # handle case of concatenated bz2 streams
        if dec.eof:
            rem = dec.unused_data
            dec = bz2.BZ2Decompressor()
            got += proc(rem)

        # show progress
        totin += len(chunk)
        totout += got
        if got != 0:    # only if a bzip2 block emitted
            frac = round(1000 * totin / size)
            if frac != prev:
                left = (size / totin - 1) * (time.time() - start)
                print(f'\r{frac / 10:.1f}% (~{left:.1f}s left) ', end='')
                prev = frac

# Show the resulting size.
print(end='\r')
print(totout, 'uncompressed bytes')
于 2019-02-09T03:16:42.103 回答
0

可以直接使用 Python 模块提供的现有高级 API，bz2同时从底层文件处理程序获取有关已处理多少压缩数据的信息。

import bz2
import datetime
import time

with bz2.open(input_filename, 'rt', encoding='utf8') as input_file:
    underlying_file = input_file.buffer._buffer.raw._fp
    underlying_file.seek(0, io.SEEK_END)
    underlying_file_size = underlying_file.tell()
    underlying_file.seek(0, io.SEEK_SET)
    lines_count = 0
    start_time = time.perf_counter()
    progress = f'{0:.2f}%'

    while True:
        line = input_file.readline().strip()
        if not line:
            break

        process_line(line)

        lines_count += 1
        current_position = underlying_file.tell()
        new_progress = f'{current_position / underlying_file_size * 100:.2f}%'
        if progress != new_progress:
            progress = new_progress
            current_time = time.perf_counter()
            elapsed_time = current_time - start_time
            elapsed = datetime.timedelta(seconds=elapsed_time)
            remaining = datetime.timedelta(seconds=(underlying_file_size / current_position - 1) * elapsed_time)
            print(f"{lines_count} lines processed, {progress}, {elapsed} elapsed, {remaining} remaining")

如果您不是在读取文本文件，而是二进制文件，那么您必须使用：

with bz2.open(input_filename, 'rb') as input_file:
    underlying_file = input_file._buffer.raw._fp
    ...
于 2021-03-23T05:00:54.873 回答
-1

在另一个答案的帮助下，我终于找到了解决方案。这个想法是使用处理的压缩文件的大小，压缩文件的总大小以及用于估计剩余时间的时间。为达到这个，

  1. 将压缩文件作为字节对象读入内存：byte_data，速度相当快
  2. 计算byte_data使用的大小total_size = len(byte_data)
  3. 换成byte_data_byte_f = io.BytesIO(byte_data)
  4. 换成byte_f_bz2f = bz2.BZ2File(byte_f)
  5. 在处理过程中，使用获取压缩文件pos = byte_f.tell()中的当前位置
  6. 计算处理的确切百分比percent = pos/total_size
  7. 记录使用时间，并计算剩余时间

几秒钟后，估计会变得非常准确：

0.01% processed, 2.00s elapsed, 17514.27s remaining...
0.02% processed, 4.00s elapsed, 20167.48s remaining...
0.03% processed, 6.00s elapsed, 21239.60s remaining...
0.04% processed, 8.00s elapsed, 21818.91s remaining...
0.05% processed, 10.00s elapsed, 22180.76s remaining...
0.05% processed, 12.00s elapsed, 22427.78s remaining...
0.06% processed, 14.00s elapsed, 22661.80s remaining...
0.07% processed, 16.00s elapsed, 22840.45s remaining...
0.08% processed, 18.00s elapsed, 22937.07s remaining...
....
99.97% processed, 22704.28s elapsed, 6.27s remaining...
99.98% processed, 22706.28s elapsed, 4.40s remaining...
99.99% processed, 22708.28s elapsed, 2.45s remaining...
100.00% processed, 22710.28s elapsed, 0.54s remaining...
于 2019-02-09T15:24:51.940 回答