我使用了hashlib（它取代了Python 2.6 / 3.0中的md5），如果我打开一个文件并将其内容放在hashlib.md5()函数中，它就能正常工作。
问题在于非常大的文件，它们的大小可能超过RAM大小。
如何在不将整个文件加载到内存的情况下获取文件的MD5哈希值？
答案 0 :(得分：214)
您需要以合适大小的块读取文件：
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()
注意：确保打开文件时将“rb”打开 - 否则会得到错误的结果。
所以要用一种方法完成所有操作 - 使用类似的东西：
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()
上面的更新基于Frerich Raabe提供的评论 - 我测试了这一点并发现它在我的Python 2.7.2 Windows安装上是正确的
我使用'jacksum'工具交叉检查结果。
jacksum -a md5 <filename>
答案 1 :(得分：138)
将文件分成128个字节的块，然后使用update()连续将它们送到MD5。
这利用了MD5具有128字节摘要块的事实。基本上，当MD5 digest()是文件时，这正是它正在做的事情。
如果确保在每次迭代时释放内存（即不将整个文件读取到内存中），则不应超过128个字节的内存。
一个例子是像这样读取块：
f = open(fileName)
while not endOfFile:
f.read(128)
答案 2 :(得分：101)
如果您关心更多pythonic（没有'while True'）阅读文件的方式，请查看以下代码：
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()
请注意，iter（）func需要一个空的字节字符串，以便返回的迭代器在EOF停止，因为read（）返回b''（不只是''）。
答案 3 :(得分：48)
这是我的@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()
答案 4 :(得分：30)
在这个帖子中使用多个评论/答案，这是我的解决方案：
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()
最后，
- 这是由社区建立的，感谢您的建议/想法。
答案 5 :(得分：7)
Python 2/3便携式解决方案
要计算校验和（md5，sha1等），您必须以二进制模式打开文件，因为您将对字节值求和：
要成为py27 / py3便携式，您应该使用io包，如下所示：
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
如果您的文件很大，您可能更喜欢按块读取文件，以避免将整个文件内容存储在内存中：
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
这里的诀窍是将iter()函数与 sentinel （空字符串）一起使用。
在这种情况下创建的迭代器将调用 o [lambda函数]，每次调用
next()方法都没有参数;如果返回的值等于sentinel，则会引发StopIteration，否则将返回该值。
如果您的文件非常很大，您可能还需要显示进度信息。您可以通过调用回调函数来执行此操作，该函数打印或记录计算的字节数量：
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
答案 6 :(得分：4)
Bastien Semene代码的重新混合，考虑了Hawkwing关于泛型散列函数的评论......
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
答案 7 :(得分：1)
如果没有阅读完整内容，你就无法获得它的md5。但你可以使用update函数逐块读取文件内容 m.update（一）; m.update（b）相当于m.update（a + b）
答案 8 :(得分：0)
我认为以下代码更像是pythonic：
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()
答案 9 :(得分：-1)
实施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()
答案 10 :(得分：-1)
我不喜欢循环。基于@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()
答案 11 :(得分：-2)
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
答案 12 :(得分：-4)
我不确定周围是不是有太多的烦恼。我最近遇到了md5和在MySQL上存储为blob的文件的问题所以我尝试了各种文件大小和简单的Python方法，即：
FileHash=hashlib.md5(FileData).hexdigest()
我发现在2Kb到20Mb的文件大小范围内没有明显的性能差异，因此无需“散列”散列。无论如何，如果Linux必须转向磁盘，它可能至少与普通程序员保持这样做的能力一样。碰巧的是，问题与md5无关。如果您使用的是MySQL，请不要忘记已存在的md5（）和sha1（）函数。