पाइथन ने "हैशिब.शा 1" को फ़ाइल के लिए "गिट हैश-ऑब्जेक्ट" से अलग क्यों किया है?

Question

मैं एक फ़ाइल के SHA-1 मान की गणना करने की कोशिश कर रहा हूं।

मैं इस स्क्रिप्ट गढ़े गए हैं: मैं इस हैश मान प्राप्त एक विशिष्ट फ़ाइल के लिए

def hashfile(filepath): 
    sha1 = hashlib.sha1() 
    f = open(filepath, 'rb') 
    try: 
     sha1.update(f.read()) 
    finally: 
     f.close() 
    return sha1.hexdigest() 

:
8c3e109ff260f7b11087974ef7bcdbdc69a0a3b9
लेकिन जब मैं Git hash_object साथ मूल्य की गणना, तो मैं यह मान मिलता है: d339346ca154f6ed9e92205c3c5c38112e761eb7

वे अलग कैसे होते हैं? क्या मैं कुछ गलत कर रहा हूं, या क्या मैं सिर्फ अंतर को अनदेखा कर सकता हूं?

Answer 1

Git इस तरह हैश गणना करता है:

def sha1OfFile(filepath): 
    import hashlib 
    with open(filepath, 'rb') as f: 
     return hashlib.sha1(f.read()).hexdigest() 

दूसरी सोचा पर::

sha1("blob " + filesize + "\0" + data) 

Reference

Answer 2

संदर्भ के लिए, अधिक संक्षिप्त संस्करण है, हालांकि मैं यह कभी नहीं देखा है, मुझे लगता है कि f.read() पूर्ण फ़ाइल से कम लौटने के लिए, या कई-गीगाबाइट फ़ाइल के लिए, स्मृति से बाहर चलाने के लिए f.read() के लिए संभावित है। ,

def sha1OfFile(filepath): 
    import hashlib 
    sha = hashlib.sha1() 
    with open(filepath, 'rb') as f: 
     for line in f: 
      sha.update(line) 
     return sha.hexdigest() 

हालांकि कोई गारंटी नहीं कि '\n' बिल्कुल फ़ाइल दिखाए जाते हैं इसलिए इस तथ्य है कि for पाश हमें ब्लॉक दे देंगे नहीं है: हर किसी की उन्नति के लिए, हम मानते हैं कि ठीक करने के लिए कैसे करते हैं: कि करने के लिए एक पहले ठीक है '\n' में समाप्त होने वाली फ़ाइल में से हमें वही समस्या मिल सकती है जो हमने मूल रूप से की थी।

def sha1OfFile(filepath): 
    import hashlib 
    sha = hashlib.sha1() 
    with open(filepath, 'rb') as f: 
     while True: 
      block = f.read(2**10) # Magic number: one-megabyte blocks. 
      if not block: break 
      sha.update(block) 
     return sha.hexdigest() 

: दुर्भाग्य से, मैं संभव के रूप में बड़ी फ़ाइल के ब्लॉक से अधिक पुनरावृति करने के लिए है, जो मुझे लगता है कि इसका मतलब है कि हम एक while True: ... break पाश के साथ और ब्लॉक आकार के लिए एक जादुई संख्या के साथ फंस रहे हैं किसी भी इसी तरह pythonic तरीका नहीं दिख रहा है

बेशक, कौन कहता है कि हम एक मेगाबाइट तारों को स्टोर कर सकते हैं। हम शायद कर सकते हैं, लेकिन क्या होगा यदि हम एक छोटे से एम्बेडेड कंप्यूटर पर हैं?

मेरी इच्छा है कि मैं एक क्लीनर तरीके के बारे में सोच सकूं जो कि बड़ी फाइलों पर स्मृति से बाहर नहीं होने की गारंटी है और इसमें जादू संख्याएं नहीं हैं और साथ ही साथ मूल सरल पायथनिक समाधान भी किया जाता है।