He usado hashlib (que reemplaza md5 en Python 2.6 / 3.0) y funcionó bien si abrí un archivo y puse su contenido en hashlib.md5()función.

El problema es con archivos muy grandes que sus tamaños podrían exceder el tamaño de RAM.

¿Cómo obtener el hash MD5 de un archivo sin cargar todo el archivo en la memoria?

Divida el archivo en fragmentos de 8192 bytes (o algún otro múltiplo de 128 bytes) y aliméntelos a MD5 consecutivamente con update().

Esto aprovecha el hecho de que MD5 tiene bloques de resumen de 128 bytes (8192 es 128 × 64). Como no está leyendo todo el archivo en la memoria, esto no utilizará mucho más de 8192 bytes de memoria.

En Python 3.8+ puedes hacer

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

Debe leer el archivo en fragmentos de tamaño adecuado:

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: Asegúrese de abrir su archivo con el 'rb' al abierto; de lo contrario, obtendrá el resultado incorrecto.

Entonces, para hacer todo en un 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()

La actualización anterior se basó en los comentarios proporcionados por Frerich Raabe, y probé esto y descubrí que era correcto en mi instalación de Windows Python 2.7.2

Verifiqué los resultados con la herramienta 'jacksum'.

jacksum -a md5 <filename>

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

A continuación he incorporado sugerencias de comentarios. Gracias al!

pitón <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 y superior

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

publicación original

si le interesa más la forma pitónica (no 'while True') de leer el archivo, 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()

Tenga en cuenta que la función iter () necesita una cadena de bytes vacía para que el iterador devuelto se detenga en EOF, ya que read () devuelve b '' (no solo '').

Aquí está mi versión del método de @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 múltiples comentarios / respuestas en este hilo, aquí está mi solución:

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

• Esto es "pitónico"
• Esta es una funcion
• Evita los valores implícitos: siempre prefiere los explícitos.
• Permite optimizaciones de rendimiento (muy importantes)

Y finalmente,

- Esto ha sido construido por una comunidad, gracias a todos por sus consejos / ideas.

Una solución portátil Python 2/3

Para calcular una suma de comprobación (md5, sha1, etc.), debe abrir el archivo en modo binario, ya que sumará los valores de bytes:

Para ser portátil py27 / py3, debe usar los iopaquetes, de esta manera:

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

Si sus archivos son grandes, puede preferir leer el archivo por partes para evitar almacenar todo el contenido del archivo en la memoria:

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

El truco aquí es usar la iter()función con un centinela (la cadena vacía).

El iterador creado en este caso llamará a o [la función lambda] sin argumentos para cada llamada a su next()método; si el valor devuelto es igual a centinela, se StopIterationelevará, de lo contrario, se devolverá el valor.

Si sus archivos son realmente grandes, es posible que también necesite mostrar información de progreso. Puede hacerlo llamando a una función de devolución de llamada que imprime o registra la cantidad 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

Una remezcla del código Bastien Semene que tiene en cuenta el comentario de Hawkwing sobre la función 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

no puedes obtener su md5 sin leer el contenido completo. pero puede usar la función de actualización para leer el contenido de los archivos bloque por bloque.
m.actualización (a); m.update (b) es equivalente a m.update (a + b)

Creo que el siguiente código es más 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()

Implementación de la respuesta aceptada para 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()

No me gustan los loops. Basado en @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

No estoy seguro de que no haya demasiado alboroto por aquí. Recientemente tuve problemas con md5 y archivos almacenados como blobs en MySQL, así que experimenté con varios tamaños de archivos y el enfoque directo de Python, a saber:

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

No pude detectar ninguna diferencia de rendimiento notable con un rango de tamaños de archivo de 2Kb a 20Mb y, por lo tanto, no es necesario 'fragmentar' el hash. De todos modos, si Linux tiene que ir al disco, probablemente lo hará al menos tan bien como la capacidad promedio del programador para evitar que lo haga. Como sucedió, el problema no tenía nada que ver con md5. Si está utilizando MySQL, no olvide las funciones md5 () y sha1 () que ya están allí.