Użyłem hashliba (który zastępuje md5 w Pythonie 2.6 / 3.0) i działało dobrze, jeśli otworzyłem plik i włączyłem jego zawartość do hashlib.md5()funkcji.

Problem dotyczy bardzo dużych plików, których rozmiar może przekraczać rozmiar pamięci RAM.

Jak uzyskać skrót MD5 pliku bez ładowania całego pliku do pamięci?

Podziel plik na 8192-bajtowe fragmenty (lub inną wielokrotność 128 bajtów) i podaj je kolejno do MD5 update().

Wykorzystuje to fakt, że MD5 ma 128-bajtowe bloki podsumowania (8192 to 128 × 64). Ponieważ nie odczytujesz całego pliku do pamięci, nie zajmie to więcej niż 8192 bajtów pamięci.

W Python 3.8+ możesz to zrobić

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

Musisz przeczytać plik w kawałkach o odpowiednim rozmiarze:

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

UWAGA: Upewnij się, że otworzyłeś plik za pomocą „rb” do otwarcia - w przeciwnym razie otrzymasz niewłaściwy wynik.

Aby wykonać cały proces za pomocą jednej metody - użyj czegoś takiego:

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

Powyższa aktualizacja była oparta na komentarzach Frericha Raabe - przetestowałem to i stwierdziłem, że jest poprawna podczas instalacji systemu Windows w Python 2.7.2

Sprawdziłem wyniki za pomocą narzędzia „jacksum”.

jacksum -a md5 <filename>

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

Poniżej zamieściłem sugestie z komentarzy. Dziękuję 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 i wyżej

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

oryginalny post

jeśli zależy Ci na bardziej pythonicznym (nie „while True”) sposobie odczytu pliku, sprawdź ten kod:

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

Zauważ, że iter () func potrzebuje pustego ciągu bajtów, aby zwrócony iterator zatrzymał się na EOF, ponieważ read () zwraca b '' (nie tylko '').

Oto moja wersja metody @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()

Korzystając z wielu komentarzy / odpowiedzi w tym wątku, oto moje rozwiązanie:

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

• To jest „python”
• To jest funkcja
• Unika wartości niejawnych: zawsze preferuj wartości jawne.
• Umożliwia (bardzo ważne) optymalizacje wydajności

I w końcu,

- Zostało to zbudowane przez społeczność, dziękuję wszystkim za porady / pomysły.

Przenośne rozwiązanie Python 2/3

Aby obliczyć sumę kontrolną (md5, sha1 itp.), Musisz otworzyć plik w trybie binarnym, ponieważ sumujesz wartości bajtów:

Aby być przenośnym py27 / py3, powinieneś użyć takich iopakietów:

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

Jeśli twoje pliki są duże, możesz chcieć przeczytać plik po kawałkach, aby uniknąć przechowywania całej zawartości pliku w pamięci:

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

Sztuczka polega na tym, aby użyć iter()funkcji z wartownikiem (pusty ciąg znaków).

Iterator utworzony w tym przypadku wywoła o [funkcję lambda] bez argumentów dla każdego wywołania swojej next()metody; jeśli zwrócona wartość jest równa wartownikowi, StopIterationzostanie podniesiona, w przeciwnym razie wartość zostanie zwrócona.

Jeśli Twoje pliki są naprawdę duże, może być konieczne wyświetlenie informacji o postępach. Możesz to zrobić, wywołując funkcję zwrotną, która drukuje lub rejestruje obliczoną liczbę bajtów:

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

Remiks kodu Bastien Semene, który bierze pod uwagę komentarz Hawkwinga na temat ogólnej funkcji skrótu ...

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

nie można dostać to md5 bez przeczytania pełnej treści. ale możesz użyć funkcji aktualizacji, aby odczytać zawartość pliku blok po bloku.
m. aktualizacja (a); m.update (b) jest równoważne m.update (a + b)

Myślę, że następujący kod jest bardziej pythonowy:

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

Realizacja zaakceptowanej odpowiedzi dla 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()

Nie lubię pętli. Na podstawie @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

Nie jestem pewien, czy nie ma tu zbyt wiele problemów. Ostatnio miałem problemy z md5 i plikami przechowywanymi jako obiekty BLOB na MySQL, więc eksperymentowałem z różnymi rozmiarami plików i prostym podejściem do Pythona, a mianowicie:

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

Nie mogłem wykryć zauważalnej różnicy wydajności w zakresie rozmiarów plików od 2Kb do 20Mb, a zatem nie ma potrzeby „dzielenia” haszowania. W każdym razie, jeśli Linux musi przejść na dysk, prawdopodobnie zrobi to co najmniej tak samo, jak zdolność przeciętnego programisty do powstrzymania tego. Tak się złożyło, że problem nie miał nic wspólnego z md5. Jeśli używasz MySQL, nie zapomnij już o funkcjach md5 () i sha1 ().