Ich habe hashlib verwendet (das md5 in Python 2.6 / 3.0 ersetzt) ​​und es hat gut funktioniert, wenn ich eine Datei geöffnet und ihren Inhalt in hashlib.md5()Funktion gesetzt habe.

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

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

Teilen Sie die Datei in 8192-Byte-Blöcke (oder ein anderes Vielfaches von 128 Byte) auf und führen Sie sie nacheinander mit MD5 ein 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, werden nicht viel mehr als 8192 Byte Speicher benötigt.

In Python 3.8+ können Sie dies 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

Sie müssen die Datei in Blöcken 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 - andernfalls erhalten Sie das falsche Ergebnis.

Um das Ganze in einer Methode zu erledigen, verwenden Sie Folgendes:

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 basiert auf den Kommentaren von Frerich Raabe - und ich habe dies getestet und festgestellt, dass es in meiner Python 2.7.2-Windows-Installation korrekt ist

Ich habe die Ergebnisse mit dem Tool 'jacksum' überprüft.

jacksum -a md5 <filename>

http://www.jonelo.de/java/jacksum/

Unten habe ich Vorschläge aus Kommentaren aufgenommen. Vielen Dank al!

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 mehr pythonische (kein 'while True') Methoden zum Lesen der Datei bevorzugen, ü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()

Beachten Sie, dass die Funktion iter () eine leere Bytezeichenfolge benötigt, damit der zurückgegebene Iterator bei EOF anhält, da read () b '' (nicht nur '') zurückgibt.

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()

Mit mehreren Kommentaren / Antworten in diesem Thread 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
• Implizite Werte werden vermieden: Bevorzugen Sie immer explizite.
• Es ermöglicht (sehr wichtige) Leistungsoptimierungen

Und schlussendlich,

- Dies wurde von einer Community erstellt. Vielen Dank für Ihre Ratschläge / Ideen.

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 py27 / py3 portabel zu sein, sollten Sie die ioPakete wie folgt verwenden :

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 in Blöcken 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 hier besteht darin, die iter()Funktion mit einem Sentinel (der leeren Zeichenfolge) zu verwenden.

Der in diesem Fall erstellte Iterator ruft o [die Lambda-Funktion] ohne Argumente für jeden Aufruf seiner next()Methode auf. Wenn der zurückgegebene Wert gleich Sentinel ist, StopIterationwird er erhöht, andernfalls wird der Wert zurückgegeben.

Wenn Ihre Dateien wirklich groß sind, müssen Sie möglicherweise auch Fortschrittsinformationen anzeigen. Sie können dies tun, indem Sie eine Rückruffunktion aufrufen, die die Anzahl 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 Semene-Code, der Hawkwing-Kommentare zur generischen Hashing-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

Sie können es nicht md5 bekommen, ohne den vollständigen Inhalt zu lesen. Sie können jedoch die Aktualisierungsfunktion verwenden, um den Dateiinhalt Block für Block zu lesen.
m.update (a); m.update (b) entspricht m.update (a + b)

Ich denke, der folgende Code ist pythonischer:

from hashlib import md5

def get_md5(fname):
    m = md5()
    with open(fname, 'rb') as fp:
        for chunk in fp:
            m.update(chunk)
    return m.hexdigest()

Implementierung der akzeptierten Antwort für Django:

import hashlib
from django.db import models


class MyModel(models.Model):
    file = models.FileField()  # any field based on django.core.files.File

    def get_hash(self):
        hash = hashlib.md5()
        for chunk in self.file.chunks(chunk_size=8192):
            hash.update(chunk)
        return hash.hexdigest()

Ich mag keine Loops. Basierend auf @Nathan Feger:

md5 = hashlib.md5()
with open(filename, 'rb') as f:
    functools.reduce(lambda _, c: md5.update(c), iter(lambda: f.read(md5.block_size * 128), b''), None)
md5.hexdigest()

import hashlib,re
opened = open('/home/parrot/pass.txt','r')
opened = open.readlines()
for i in opened:
    strip1 = i.strip('\n')
    hash_object = hashlib.md5(strip1.encode())
    hash2 = hash_object.hexdigest()
    print hash2

Ich bin mir nicht sicher, ob es hier nicht zu viel Aufhebens gibt. Ich hatte kürzlich Probleme mit md5 und Dateien, die als Blobs auf MySQL gespeichert waren, also experimentierte ich mit verschiedenen Dateigrößen und dem einfachen Python-Ansatz, nämlich:

FileHash=hashlib.md5(FileData).hexdigest()

Ich konnte keinen merklichen Leistungsunterschied bei einem Bereich von Dateigrößen von 2 KB bis 20 MB feststellen und musste daher das Hashing nicht "aufteilen". Wenn Linux auf die Festplatte gehen muss, wird es dies wahrscheinlich mindestens genauso gut tun wie die Fähigkeit des durchschnittlichen Programmierers, dies zu verhindern. Das Problem hatte übrigens nichts mit md5 zu tun. Wenn Sie MySQL verwenden, vergessen Sie nicht die bereits vorhandenen Funktionen md5 () und sha1 ().