Ik heb geprobeerd op internet te zoeken, maar kon de betekenis van hashable niet vinden.
Als ze zeggen dat objecten hashableof hashable objectszijn, wat betekent dat dan?
Antwoord 1, autoriteit 100%
Uit de Python-woordenlijst:
Een object is hashbaar als het een hash-waarde heeft die tijdens zijn levensduur nooit verandert (het heeft een
__hash__()-methode nodig) en kan worden vergeleken met andere objecten (het heeft een__eq__()of__cmp__()methode). Hash-objecten die gelijk zijn, moeten dezelfde hash-waarde hebben.Hashability maakt een object bruikbaar als een woordenboeksleutel en een setlid, omdat deze gegevensstructuren de hash-waarde intern gebruiken.
Alle onveranderlijke ingebouwde objecten van Python zijn hashbaar, terwijl geen veranderlijke containers (zoals lijsten of woordenboeken) dat zijn. Objecten die instanties zijn van door de gebruiker gedefinieerde klassen zijn standaard hashbaar; ze vergelijken allemaal ongelijk, en hun hash-waarde is hun
id().
Antwoord 2, autoriteit 55%
Alle antwoorden hier hebben een goed werkende uitleg van hashbare objecten in python, maar ik geloof dat je eerst de term hashing moet begrijpen.
Hashingis een concept in de informatica dat wordt gebruikt om hoogwaardige, pseudo-willekeurige toegangsgegevensstructuren te creëren waarin grote hoeveelheden gegevens moeten worden opgeslagen en snel moeten worden geopend.
Als u bijvoorbeeld 10.000 telefoonnummers heeft en deze wilt opslaan in een array (een sequentiële gegevensstructuur die gegevens op aaneengesloten geheugenlocaties opslaat en willekeurige toegang biedt), maar u misschien niet over de vereiste aantal aaneengesloten geheugenlocaties.
Je kunt dus in plaats daarvan een array van grootte 100 gebruiken en een hash-functie gebruiken om een set waarden toe te wijzen aan dezelfde indices, en deze waarden kunnen worden opgeslagen in een gekoppelde lijst. Dit levert een prestatie op die vergelijkbaar is met een array.
Nu kan een hash-functie zo simpel zijn als het getal delen door de grootte van de array en de rest als index nemen.
Raadpleeg voor meer informatie https://en.wikipedia.org/wiki/Hash_function
Hier is nog een goede referentie: http://interactivepython.org/runestone/ static/pythonds/SortSearch/Hashing.html
Antwoord 3, autoriteit 10%
Alles dat niet veranderlijk is (veranderlijk betekent, waarschijnlijk zal veranderen) kan worden gehasht. Naast de hash-functie waarnaar moet worden gezocht, als een klasse deze heeft, door bijv. dir(tuple)en op zoek naar de __hash__methode, hier zijn enkele voorbeelden
#x = hash(set([1,2])) #set unhashable
x = hash(frozenset([1,2])) #hashable
#x = hash(([1,2], [2,3])) #tuple of mutable objects, unhashable
x = hash((1,2,3)) #tuple of immutable objects, hashable
#x = hash()
#x = hash({1,2}) #list of mutable objects, unhashable
#x = hash([1,2,3]) #list of immutable objects, unhashable
Lijst met onveranderlijke typen:
int, float, decimal, complex, bool, string, tuple, range, frozenset, bytes
Lijst met veranderlijke typen:
list, dict, set, bytearray, user-defined classes
Antwoord 4, autoriteit 8%
Als ik het volgens de Python-woordenlijst begrijp, wordt er bij het maken van een instantie van objecten die hashbaar zijn, ook een onveranderlijke waarde berekend op basis van de leden of waarden van de instantie.
Die waarde zou dan bijvoorbeeld als sleutel in een woordenboek kunnen worden gebruikt, zoals hieronder:
>>> tuple_a = (1, 2, 3)
>>> tuple_a.__hash__()
2528502973977326415
>>> tuple_b = (2, 3, 4)
>>> tuple_b.__hash__()
3789705017596477050
>>> tuple_c = (1, 2, 3)
>>> tuple_c.__hash__()
2528502973977326415
>>> id(a) == id(c) # a and c same object?
False
>>> a.__hash__() == c.__hash__() # a and c same value?
True
>>> dict_a = {}
>>> dict_a[tuple_a] = 'hiahia'
>>> dict_a[tuple_c]
'hiahia'
We kunnen zien dat de hash-waarde van tuple_aen tuple_chetzelfde is omdat ze dezelfde leden hebben.
Als we tuple_agebruiken als de sleutel in dict_a, kunnen we zien dat de waarde voor dict_a[tuple_c]hetzelfde is, wat betekent dat, wanneer ze worden gebruikt als de sleutel in een woordenboek, retourneren ze dezelfde waarde omdat de hash-waarden hetzelfde zijn.
Voor die objecten die niet hashbaar zijn, wordt de methode __hash__gedefinieerd als None:
>>> type(dict.__hash__)
<class 'NoneType'>
Ik denk dat deze hash-waarde wordt berekend bij de initialisatie van de instantie, niet op een dynamische manier, daarom zijn alleen onveranderlijke objecten hashbaar. Ik hoop dat dit helpt.
Antwoord 5, autoriteit 5%
Hashable = kan worden gehasht.
Ok, wat is hashen? Een hashfunctie is een functie die een object, bijvoorbeeld een tekenreeks zoals ‘Python’, nodig heeft en een code met een vaste grootte retourneert. Neem voor de eenvoud aan dat de geretourneerde waarde een geheel getal is.
Als ik hash(‘Python’) in Python 3 uitvoer, krijg ik 5952713340227947791 als resultaat. Verschillende versies van Python zijn vrij om de onderliggende hash-functie te wijzigen, dus je krijgt waarschijnlijk een andere waarde. Het belangrijkste is dat, ongeacht hoe vaak ik hash(‘Python’) gebruik, ik altijd hetzelfde resultaat krijg met dezelfde versie van Python.
Maar hash(‘Java’) geeft 1753925553814008565 terug. Dus als het object dat ik aan het hashen ben verandert, verandert ook het resultaat. Aan de andere kant, als het object dat ik hash niet verandert, blijft het resultaat hetzelfde.
Waarom is dit belangrijk?
Nou, Python-woordenboeken vereisen bijvoorbeeld dat de sleutels onveranderlijk zijn. Dat wil zeggen dat sleutels objecten moeten zijn die niet veranderen. Strings zijn onveranderlijk in Python, net als de andere basistypen (int, float, bool). Tuples en frozensets zijn ook onveranderlijk. Lijsten zijn daarentegen niet onveranderlijk (d.w.z. ze zijn veranderlijk) omdat u ze kunt wijzigen. Op dezelfde manier zijn dictaten veranderlijk.
Dus als we zeggen dat iets hashable is, bedoelen we dat het onveranderlijk is. Als ik probeer een veranderlijk type door te geven aan de hash()-functie, zal het mislukken:
>>> hash('Python')
1687380313081734297
>>> hash('Java')
1753925553814008565
>>>
>>> hash([1, 2])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash({1, 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> hash({1 : 2})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>>
>>> hash(frozenset({1, 2}))
-1834016341293975159
>>> hash((1, 2))
3713081631934410656
Antwoord 6, autoriteit 4%
In Python is elk onveranderlijk object (zoals een geheel getal, boolean, string, tuple) hashbaar, wat betekent dat de waarde ervan niet verandert tijdens zijn levensduur. Hierdoor kan Python een unieke hash-waarde maken om deze te identificeren, die door woordenboeken kan worden gebruikt om unieke sleutels en sets te volgen om unieke waarden bij te houden.
Daarom vereist Python dat we onveranderlijke datatypes gebruiken voor de sleutels in een woordenboek.
Antwoord 7, autoriteit 2%
Laat me je een werkend voorbeeld geven om de hash-objecten in python te begrijpen. Ik neem voor dit voorbeeld 2 Tuples. Elke waarde in een tuple heeft een unieke Hash-waarde die tijdens zijn levensduur nooit verandert. Dus op basis hiervan heeft waarde, de vergelijking tussen twee tupels wordt gedaan. We kunnen de hash-waarde van een tuple-element krijgen met behulp van de Id().
Antwoord 8, autoriteit 2%
In python betekent dit dat het object lid kan zijn van sets om een index te retourneren. Dat wil zeggen, ze hebben een unieke identiteit/id.
bijvoorbeeld in python 3.3:
de datastructuur Lijsten zijn niet hashbaar, maar de datastructuur Tuples zijn hashbaar.
Antwoord 9
Om een geheel nieuwe hash-tabel te maken, moeten alle waarden worden ingesteld op “Geen” en worden gewijzigd zodra een vereiste zich voordoet.
Hashable-objecten verwijzen naar de aanpasbare datatypes (woordenboek, lijsten, enz.). Aan de andere kant kunnen sets niet opnieuw worden geïnitialiseerd nadat ze zijn toegewezen, dus sets kunnen niet worden gehasht. Terwijl de variant van set() — frozenset() — hashable is.