Eu usei o hashlib (que substitui o md5 no Python 2.6 / 3.0) e funcionou bem se eu abrisse um arquivo e colocasse seu conteúdo em hashlib.md5() função.

O problema é com arquivos muito grandes que seus tamanhos podem exceder o tamanho da RAM.

Como obter o hash MD5 de um arquivo sem carregar o arquivo inteiro na memória?

Divida o arquivo em pedaços de 8192 bytes (ou algum outro múltiplo de 128 bytes) e alimente-os no MD5 consecutivamente usando update().

Isso tira proveito do fato de o MD5 ter blocos de resumo de 128 bytes (8192 é 128 × 64). Como você não está lendo o arquivo inteiro na memória, isso não usará muito mais do que 8192 bytes de memória.

No Python 3.8 ou superior, você pode fazer

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

Você precisa ler o arquivo em pedaços de tamanho adequado:

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

NOTA: Certifique-se de abrir seu arquivo com o 'rb' para abrir; caso contrário, você obterá o resultado errado.

Então, para fazer o lote inteiro em um método - use algo como:

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

A atualização acima foi baseada nos comentários fornecidos por Frerich Raabe - e eu testei isso e achei que estava correto na minha instalação do Windows Python 2.7.2

Eu verifiquei os resultados usando a ferramenta 'jacksum'.

jacksum -a md5 <filename>

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

Abaixo incorporei a sugestão dos comentários. Obrigado a todos!

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 e acima

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

postagem original

se você se preocupa com a maneira mais pitônica (sem 'enquanto True') de ler o arquivo, verifique este código:

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

Observe que a função iter () precisa de uma cadeia de bytes vazia para o iterador retornado parar no EOF, pois read () retorna b '' (não apenas '').

Aqui está minha versão do método @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()

Usando vários comentários / respostas neste tópico, aqui está minha solução:

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

• Isso é "pitônico"
• Esta é uma função
• Evita valores implícitos: sempre prefira valores explícitos.
• Permite otimizações de desempenho (muito importantes)

E finalmente,

- Isso foi construído por uma comunidade, obrigado a todos por seus conselhos / idéias.

Uma solução portátil Python 2/3

Para calcular uma soma de verificação (md5, sha1 etc.), você deve abrir o arquivo no modo binário, porque você somará valores de bytes:

Para ser portátil py27 / py3, você deve usar os iopacotes, assim:

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

Se seus arquivos forem grandes, convém ler o arquivo em pedaços para evitar armazenar todo o conteúdo do arquivo na memória:

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

O truque aqui é usar a iter()função com uma sentinela (a sequência vazia).

O iterador criado neste caso chamará o [a função lambda] sem argumentos para cada chamada ao seu next()método; se o valor retornado for igual a sentinel, StopIterationserá aumentado; caso contrário, o valor será retornado.

Se seus arquivos forem realmente grandes, talvez você também precise exibir informações de progresso. Você pode fazer isso chamando uma função de retorno de chamada que imprime ou registra a quantidade de bytes calculados:

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

Um remix do código Bastien Semene que leva em consideração o comentário de Hawkwing sobre a função de hash genérica ...

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

você não pode obtê-lo MD5 sem ler o conteúdo completo. mas você pode usar a função de atualização para ler o conteúdo dos arquivos bloco por bloco.
m.update (a); m.update (b) é equivalente a m.update (a + b)

Eu acho que o código a seguir é mais pitônico:

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

Implementação da resposta aceita para o 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()

Eu não gosto de loops. Baseado em @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

Não tenho certeza de que não haja muita confusão por aqui. Recentemente, tive problemas com md5 e arquivos armazenados como blobs no MySQL, então experimentei vários tamanhos de arquivo e a abordagem direta do Python, a saber:

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

Não pude detectar nenhuma diferença perceptível de desempenho com uma variedade de tamanhos de arquivo de 2 KB a 20 Mb e, portanto, não há necessidade de "dividir" o hash. De qualquer forma, se o Linux tiver que ir para o disco, provavelmente o fará pelo menos assim como a capacidade do programador médio de impedir que isso aconteça. Por acaso, o problema não estava relacionado ao MD5. Se você estiver usando o MySQL, não esqueça as funções md5 () e sha1 () já existentes.