Tôi đã sử dụng hashlib (thay thế md5 trong Python 2.6 / 3.0) và nó hoạt động tốt nếu tôi mở một tệp và đưa nội dung của nó vào hashlib.md5()chức năng.

Vấn đề là với các tệp rất lớn mà kích thước của chúng có thể vượt quá kích thước RAM.

Làm cách nào để lấy băm MD5 của một tệp mà không tải toàn bộ tệp vào bộ nhớ?

Chia tệp thành các khối 8192 byte (hoặc một số bội số khác của 128 byte) và đưa chúng vào MD5 liên tiếp bằng cách sử dụng update().

Điều này lợi dụng thực tế là MD5 có các khối digest 128 byte (8192 là 128 × 64). Vì bạn không đọc toàn bộ tệp vào bộ nhớ, nên điều này sẽ không sử dụng nhiều hơn 8192 byte bộ nhớ.

Trong Python 3.8+ bạn có thể làm

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

Bạn cần đọc các tập tin trong khối có kích thước phù hợp:

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

LƯU Ý: Đảm bảo bạn mở tệp của mình bằng 'rb' để mở - nếu không bạn sẽ nhận được kết quả sai.

Vì vậy, để thực hiện toàn bộ lô trong một phương thức - sử dụng một cái gì đó như:

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

Bản cập nhật ở trên dựa trên các nhận xét được cung cấp bởi Frerich Raabe - và tôi đã thử nghiệm điều này và thấy nó là chính xác khi cài đặt cửa sổ Python 2.7.2 của tôi

Tôi đã kiểm tra chéo kết quả bằng công cụ 'jacksum'.

jacksum -a md5 <filename>

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

Dưới đây tôi đã kết hợp đề xuất từ ​​ý kiến. Cảm ơn bạn

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

trăn 3,8 trở lên

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

bài gốc

nếu bạn quan tâm đến cách đọc tệp pythonic (không 'trong khi True'), hãy kiểm tra mã này:

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

Lưu ý rằng func iter () cần một chuỗi byte trống để trình lặp được trả về tạm dừng tại EOF, vì read () trả về b '' (không chỉ '').

Đây là phiên bản của phương thức @Piotr Czapla của tôi:

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

Sử dụng nhiều bình luận / câu trả lời trong chủ đề này, đây là giải pháp của tôi:

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

• Đây là "pythonic"
• Đây là một chức năng
• Nó tránh các giá trị ngầm định: luôn thích những giá trị rõ ràng.
• Nó cho phép tối ưu hóa (rất quan trọng) hiệu suất

Và cuối cùng,

- Điều này đã được xây dựng bởi một cộng đồng, cảm ơn tất cả những lời khuyên / ý tưởng của bạn.

Giải pháp di động Python 2/3

Để tính toán tổng kiểm tra (md5, sha1, v.v.), bạn phải mở tệp ở chế độ nhị phân, vì bạn sẽ tính tổng các giá trị byte:

Để có thể mang theo py27 / py3, bạn nên sử dụng các iogói, như thế này:

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

Nếu tệp của bạn lớn, bạn có thể thích đọc tệp theo từng đoạn để tránh lưu trữ toàn bộ nội dung tệp trong bộ nhớ:

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

Mẹo ở đây là sử dụng iter()hàm với sentinel (chuỗi rỗng).

Trình lặp được tạo trong trường hợp này sẽ gọi o [hàm lambda] không có đối số cho mỗi lệnh gọi đến next()phương thức của nó ; nếu giá trị được trả về bằng sentinel, StopIterationsẽ được nâng lên, nếu không giá trị sẽ được trả về.

Nếu các tệp của bạn thực sự lớn, bạn cũng có thể cần hiển thị thông tin tiến trình. Bạn có thể làm điều đó bằng cách gọi một hàm gọi lại in hoặc ghi lại số lượng byte được tính toán:

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

Một bản phối lại của mã Bastien Semene đưa nhận xét của Hawkwing về chức năng băm chung ...

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

bạn không thể lấy nó md5 mà không đọc nội dung đầy đủ. nhưng bạn có thể sử dụng chức năng cập nhật để đọc khối nội dung tệp theo từng khối.
m.update (a); m.update (b) tương đương với m.update (a + b)

Tôi nghĩ đoạn mã sau có tính chất pythonic hơn:

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

Thực hiện câu trả lời được chấp nhận cho 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()

Tôi không thích các vòng lặp. Dựa trên @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

Tôi không chắc chắn rằng không có quá nhiều sự ồn ào quanh đây. Gần đây tôi gặp vấn đề với md5 và các tệp được lưu trữ dưới dạng blobs trên MySQL vì vậy tôi đã thử nghiệm với nhiều kích cỡ tệp khác nhau và cách tiếp cận Python đơn giản, viz:

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

Tôi có thể phát hiện không có sự khác biệt hiệu suất đáng chú ý với một phạm vi kích thước tệp 2Kb đến 20Mb và do đó không cần phải 'băm' băm. Dù sao, nếu Linux phải vào đĩa, có lẽ nó sẽ làm điều đó ít nhất cũng như khả năng của lập trình viên trung bình để giữ cho nó không làm như vậy. Như đã xảy ra, vấn đề không liên quan gì đến md5. Nếu bạn đang sử dụng MySQL, đừng quên các hàm md5 () và sha1 () đã có.