टी एल; डॉ:
कृपया शब्दकोष का संदर्भ लें : hash()वस्तुओं की तुलना करने के लिए एक शॉर्टकट के रूप में उपयोग किया जाता है, यदि किसी वस्तु को अन्य वस्तुओं की तुलना में धोया जा सकता है। यही कारण है कि हम उपयोग करते हैं hash()। इसका उपयोग उन तत्वों dictऔर setउपयोगों के लिए भी किया जाता है जिन्हें CPython में resizable हैश टेबल के रूप में कार्यान्वित किया जाता है ।
तकनीकी विचार
- आमतौर पर वस्तुओं की तुलना करना (जिसमें कई स्तरों की पुनरावृत्ति शामिल हो सकती है) महंगी होती है।
- अधिमानतः,
hash()फ़ंक्शन कम मात्रा में परिमाण (या कई) का एक आदेश है।
- दो हैश की तुलना दो वस्तुओं की तुलना में आसान है, यह वह जगह है जहां शॉर्टकट है।
यदि आप इस बारे में पढ़ते हैं कि शब्दकोशों को कैसे लागू किया जाता है , तो वे हैश टेबल का उपयोग करते हैं, जिसका अर्थ है कि ऑब्जेक्ट से एक कुंजी प्राप्त करना, शब्दकोशों में वस्तुओं को पुनः प्राप्त करने के लिए एक कोने का पत्थर है O(1)। हालांकि यह टक्कर-प्रतिरोधी होने के लिए आपके हैश फ़ंक्शन पर बहुत निर्भर है । एक आइटम प्राप्त करने के लिए सबसे खराब स्थिति एक शब्दकोश में वास्तव में है O(n)।
उस नोट पर, उत्परिवर्तनीय वस्तुएं आमतौर पर धोने योग्य नहीं होती हैं। धोने योग्य संपत्ति का मतलब है कि आप एक कुंजी के रूप में एक वस्तु का उपयोग कर सकते हैं। यदि हैश मान एक कुंजी के रूप में उपयोग किया जाता है और उसी वस्तु की सामग्री बदल जाती है, तो हैश फ़ंक्शन क्या लौटना चाहिए? यह एक ही कुंजी या एक अलग है? यह इस बात पर निर्भर करता है कि आप अपने हैश फ़ंक्शन को कैसे परिभाषित करते हैं।
उदाहरण से सीखना:
कल्पना कीजिए कि हमारे पास यह वर्ग है:
>>> class Person(object):
... def __init__(self, name, ssn, address):
... self.name = name
... self.ssn = ssn
... self.address = address
... def __hash__(self):
... return hash(self.ssn)
... def __eq__(self, other):
... return self.ssn == other.ssn
...
कृपया ध्यान दें: यह सब इस धारणा पर आधारित है कि SSN किसी व्यक्ति के लिए कभी नहीं बदलता (यह भी नहीं पता कि वास्तव में आधिकारिक स्रोत से उस तथ्य को कहां सत्यापित किया जाए)।
और हमारे पास बॉब है:
>>> bob = Person('bob', '1111-222-333', None)
बॉब अपना नाम बदलने के लिए एक न्यायाधीश को देखने जाता है:
>>> jim = Person('jim bo', '1111-222-333', 'sf bay area')
यह हम जानते हैं:
>>> bob == jim
True
लेकिन ये दो अलग-अलग ऑब्जेक्ट हैं जो अलग-अलग मेमोरी आवंटित करते हैं, जैसे एक ही व्यक्ति के दो अलग-अलग रिकॉर्ड:
>>> bob is jim
False
अब वह हिस्सा आता है जहाँ हैश () काम है:
>>> dmv_appointments = {}
>>> dmv_appointments[bob] = 'tomorrow'
अंदाज़ा लगाओ:
>>> dmv_appointments[jim]
'tomorrow'
दो अलग-अलग रिकॉर्ड्स से आप एक ही जानकारी हासिल कर सकते हैं। अब यह प्रयास करें:
>>> dmv_appointments[hash(jim)]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 9, in __eq__
AttributeError: 'int' object has no attribute 'ssn'
>>> hash(jim) == hash(hash(jim))
True
अभी क्या हुआ? वह टक्कर है। क्योंकि hash(jim) == hash(hash(jim))जो दोनों पूर्णांक btw हैं, हमें __getitem__उन सभी वस्तुओं के इनपुट की तुलना करने की आवश्यकता है जो टकराते हैं। बिलिन intमें एक ssnविशेषता नहीं है इसलिए यह यात्रा करता है।
>>> del Person.__eq__
>>> dmv_appointments[bob]
'tomorrow'
>>> dmv_appointments[jim]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: <__main__.Person object at 0x7f611bd37110>
इस अंतिम उदाहरण में, मैं बताता हूं कि टक्कर के साथ भी, तुलना की जाती है, वस्तुएं अब समान नहीं हैं, जिसका अर्थ है कि यह सफलतापूर्वक एक है KeyError।