Holen Sie sich den MD5-Hash großer Dateien in Python

Ich habe benutzt Hashlib (was ersetzt md5 in Python 2.6/3.0), und es funktionierte gut, wenn ich eine Datei öffnete und ihren Inhalt in die hashlib.md5() Funktion.

Das Problem bei sehr großen Dateien besteht darin, dass ihre Größe die RAM-Größe überschreiten kann.

Wie kann ich den MD5-Hash einer Datei abrufen, ohne die gesamte Datei in den Speicher zu laden?

Sie müssen die Datei in Abschnitten geeigneter Größe lesen:

def md5_for_file(f, block_size=2**20):
    md5 = hashlib.md5()
    while True:
        data = f.read(block_size)
        if not data:
            break
        md5.update(data)
    return md5.digest()

Hinweis: Stellen Sie sicher, dass Sie Ihre Datei mit dem ‘rb’ zum Öffnen öffnen – sonst erhalten Sie ein falsches Ergebnis.

Um also alles in einer Methode zu erledigen, verwenden Sie so etwas wie:

def generate_file_md5(rootdir, filename, blocksize=2**20):
    m = hashlib.md5()
    with open( os.path.join(rootdir, filename) , "rb" ) as f:
        while True:
            buf = f.read(blocksize)
            if not buf:
                break
            m.update( buf )
    return m.hexdigest()

Das obige Update basierte auf den Kommentaren von Frerich Raabe – und ich habe dies getestet und festgestellt, dass es auf meiner Windows-Installation von Python 2.7.2 korrekt ist

Ich habe die Ergebnisse mit dem überprüft Jacksum Werkzeug.

jacksum -a md5 <filename>

Brechen Sie die Datei in 8192-Byte-Blöcke (oder ein anderes Vielfaches von 128 Bytes) auf und füttern Sie sie nacheinander mit MD5 update().

Dies nutzt die Tatsache aus, dass MD5 128-Byte-Digest-Blöcke hat (8192 ist 128 × 64). Da Sie nicht die gesamte Datei in den Speicher einlesen, verbraucht dies nicht viel mehr als 8192 Byte Speicher.

In Python 3.8+ können Sie das tun

import hashlib
with open("your_filename.txt", "rb") as f:
    file_hash = hashlib.md5()
    while chunk := f.read(8192):
        file_hash.update(chunk)
print(file_hash.digest())
print(file_hash.hexdigest())  # to get a printable str instead of bytes

Python < 3.7

import hashlib

def checksum(filename, hash_factory=hashlib.md5, chunk_num_blocks=128):
    h = hash_factory()
    with open(filename,'rb') as f: 
        for chunk in iter(lambda: f.read(chunk_num_blocks*h.block_size), b''): 
            h.update(chunk)
    return h.digest()

Python 3.8 und höher

import hashlib

def checksum(filename, hash_factory=hashlib.md5, chunk_num_blocks=128):
    h = hash_factory()
    with open(filename,'rb') as f: 
        while chunk := f.read(chunk_num_blocks*h.block_size): 
            h.update(chunk)
    return h.digest()

Ursprünglicher Beitrag

Wenn Sie eine pythonischere (Nr while True) zum Lesen der Datei, überprüfen Sie diesen Code:

import hashlib

def checksum_md5(filename):
    md5 = hashlib.md5()
    with open(filename,'rb') as f: 
        for chunk in iter(lambda: f.read(8192), b''): 
            md5.update(chunk)
    return md5.digest()

Notiere dass der iter() Die Funktion benötigt eine leere Bytezeichenfolge, damit der zurückgegebene Iterator bei EOF anhält, da read() kehrt zurück b'' (nicht nur '').

Hier ist meine Version der Methode von Piotr Czapla:

def md5sum(filename):
    md5 = hashlib.md5()
    with open(filename, 'rb') as f:
        for chunk in iter(lambda: f.read(128 * md5.block_size), b''):
            md5.update(chunk)
    return md5.hexdigest()

Unter Verwendung mehrerer Kommentare/Antworten für diese Frage ist hier meine Lösung:

import hashlib
def md5_for_file(path, block_size=256*128, hr=False):
    '''
    Block size directly depends on the block size of your filesystem
    to avoid performances issues
    Here I have blocks of 4096 octets (Default NTFS)
    '''
    md5 = hashlib.md5()
    with open(path,'rb') as f:
        for chunk in iter(lambda: f.read(block_size), b''):
             md5.update(chunk)
    if hr:
        return md5.hexdigest()
    return md5.digest()

• Das ist Pythonisch
• Dies ist eine Funktion
• Es vermeidet implizite Werte: immer explizite bevorzugen.
• Es ermöglicht (sehr wichtige) Leistungsoptimierungen

Eine tragbare Python 2/3-Lösung

Um eine Prüfsumme (md5, sha1 usw.) zu berechnen, müssen Sie die Datei im Binärmodus öffnen, da Sie Bytewerte summieren:

Um Python 2.7 und Python 3 portabel zu sein, sollten Sie die verwenden io Pakete, etwa so:

import hashlib
import io


def md5sum(src):
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        content = fd.read()
        md5.update(content)
    return md5

Wenn Ihre Dateien groß sind, ziehen Sie es möglicherweise vor, die Datei stückweise zu lesen, um zu vermeiden, dass der gesamte Dateiinhalt im Speicher gespeichert wird:

def md5sum(src, length=io.DEFAULT_BUFFER_SIZE):
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        for chunk in iter(lambda: fd.read(length), b''):
            md5.update(chunk)
    return md5

Der Trick dabei ist, die zu verwenden iter() Funktion mit a Wächter (die leere Zeichenfolge).

Der in diesem Fall erstellte Iterator ruft auf Ö [the lambda function] ohne Argumente für jeden Aufruf von its next() Methode; wenn der zurückgegebene Wert gleich Sentinel ist, StopIteration wird erhöht, andernfalls wird der Wert zurückgegeben.

Wenn Ihre Dateien sind Ja wirklich groß, müssen Sie möglicherweise auch Fortschrittsinformationen anzeigen. Sie können dies tun, indem Sie eine Callback-Funktion aufrufen, die die Menge der berechneten Bytes druckt oder protokolliert:

def md5sum(src, callback, length=io.DEFAULT_BUFFER_SIZE):
    calculated = 0
    md5 = hashlib.md5()
    with io.open(src, mode="rb") as fd:
        for chunk in iter(lambda: fd.read(length), b''):
            md5.update(chunk)
            calculated += len(chunk)
            callback(calculated)
    return md5

Ein Remix von Bastien Semenes Code, der den Hawkwing-Kommentar zur generischen Hash-Funktion berücksichtigt …

def hash_for_file(path, algorithm=hashlib.algorithms[0], block_size=256*128, human_readable=True):
    """
    Block size directly depends on the block size of your filesystem
    to avoid performances issues
    Here I have blocks of 4096 octets (Default NTFS)

    Linux Ext4 block size
    sudo tune2fs -l /dev/sda5 | grep -i 'block size'
    > Block size:               4096

    Input:
        path: a path
        algorithm: an algorithm in hashlib.algorithms
                   ATM: ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')
        block_size: a multiple of 128 corresponding to the block size of your filesystem
        human_readable: switch between digest() or hexdigest() output, default hexdigest()
    Output:
        hash
    """
    if algorithm not in hashlib.algorithms:
        raise NameError('The algorithm "{algorithm}" you specified is '
                        'not a member of "hashlib.algorithms"'.format(algorithm=algorithm))

    hash_algo = hashlib.new(algorithm)  # According to hashlib documentation using new()
                                        # will be slower then calling using named
                                        # constructors, ex.: hashlib.md5()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(block_size), b''):
             hash_algo.update(chunk)
    if human_readable:
        file_hash = hash_algo.hexdigest()
    else:
        file_hash = hash_algo.digest()
    return file_hash