Оценочная сжимаемость файла

Вот а (надежда эквивалентная) версия Python раствор Стефане Чазелас

python -c "
import zlib
from itertools import islice
from functools import partial
import sys
with open(sys.argv[1]) as f:
  compressor = zlib.compressobj()
  t, z = 0, 0.0
  for chunk in islice(iter(partial(f.read, 4096), ''), 0, None, 10):
    t += len(chunk)
    z += len(compressor.compress(chunk))
  z += len(compressor.flush())
  print z/t
" file

У меня был много -гигабайтный файл, и я не был уверен, сжат ли он, поэтому я протестировал -сжатие первых 10 МБ байтов:

head -c 10000000 large_file.bin | gzip | wc -c

Это не идеально, но мне помогло.

Я написал быстрый скрипт для рекурсивной проверки каждого файла в каталоге и последующего сжатия только наиболее сжимаемых файлов. Он захватывает пару мегабайт внутри файла и проверяет их с помощью gzip --fast, а затем использует xzдля сжатия файла, если это необходимо.

Вы можете запустить его с :./compress.if.compressible dir _name

cores=$(grep '^core id' /proc/cpuinfo | sort -u | wc -l)

IFS=$'\n'
for file in $(find "$1" -type f); do

#Skip small files. The savings is minimal and sometimes xz just makes these larger.
size_b=`du --apparent-size -b "$file" | sed 's/\t.*//'`
if [[ $size_b -le 1024 ]]; then
    echo -e "\nSkipping small file $file"
    continue
fi

size=`du --apparent-size --block-size=1M "$file" | sed 's/\t.*//'`
reduction=$(dd if="$file" bs=1M count=2 skip=$(expr $size / 3) 2>/dev/null | gzip --fast -v 2>&1 > /dev/null)

echo -e "\n$reduction $file"

if [[ $(echo $reduction | sed 's/\..*//') -ge 20 ]]; then
    echo "$size_b *.9 > 90" | bc
    xz -v -T $cores "$file"
    new_size=`du --apparent-size -b "$file.xz" | sed 's/\t.*//'`
    if [[ `echo "$new_size * 100 / $size_b" | bc` -ge 90 ]]; then
        echo "Insufficent Compression. Reverting..."
        unxz "$file.xz"
    fi
fi

done

Вот улучшенная версия Python, основанная на замечательном решении iruvar . Основное улучшение заключается в том, что скрипт считывает с диска только те блоки данных, которые он фактически сжимает :

import zlib
def Predict_file_compression_ratio(MyFilePath):
 blocksize = (4096 * 1) # Increase if you want to read more bytes per block at once.
 blocksize_seek = 0

 # r = read, b = binary
 with open(MyFilePath, "rb") as f:
  # Make a zlib compressor object, and set compression level.
  # 1 is fastest, 9 is slowest
  compressor = zlib.compressobj(1)
  t, z, counter = 0, 0, 0

  while True:
    # Use this modulo calculation to check every "number" of blocks.
    if counter % 10 == 0:
      # Seek to the correct byte position of the file.
      f.seek(blocksize_seek)
      # The block above will be read, increase the seek distance by one block for the next iteration.
      blocksize_seek += blocksize
      # Read data chunk of file into this variable.
      data = f.read(blocksize)
      
      # Stop if there are no more data.
      if not data:
        # For zlib: Flush any remaining compressed data. Not doing this can lead to a tiny inaccuracy.
        z += len(compressor.flush())
        break

      # Uncompressed data size, add size to variable to get a total value.
      t += len(data)
      # Compressed data size
      z += len(compressor.compress(data))

    # When we skip, we want to increase the seek distance. This is vital for correct skipping.
    else:
      blocksize_seek += blocksize
    # Increase the block / iteration counter.
    counter += 1

 # Print the results. But avoid division by 0 >_>
 if not t == 0:
  print('Compression ratio: ' + str(z/t))
 else:
  print('Compression ratio: none, file has no content.')
 print('Compressed: ' + str(z))
 print('Uncompressed: ' + str(t))

Если высокая скорость передачи данных имеет решающее значение, а точные коэффициенты сжатия не так важны, вместо этого вы можете использовать lz4. Это здорово, если вы хотите узнать, какие файлы можно сжать больше всего при низкой загрузке ЦП. Этот модуль необходимо установить с помощью pip отсюда . В самом коде Python вам понадобится только это:

import lz4.block
z += len(lz4.block.compress(data))

Обратите внимание, я заметил, что использование этого скрипта приводит к перегрузке резервной памяти (точно в Windows ), что снижает производительность файлов -, особенно на компьютерах с классическими жесткими дисками, и если вы используете эту функцию для большого количества файлов одновременно. Этого засорения памяти можно избежать, установив низкий приоритет страницы памяти для процесса Python скрипта. Я решил сделать это с помощью AutoHotkey в Windows. Полезный источник здесь .