what does it mean to be hashable python

iii Essential Questions Well-nigh Hashable in Python

From full general discussion to specific implementation

Photo past Yeshi Kangrang on Unsplash

As a general-purpose programming language, Python provides a good range of congenital-in data types for various use cases.

When you learned these basics, you have probably encountered the mentioning of hashable at sure points. For instance, y'all may see that the keys in a dict need to exist hashable (run into a trivial case in the code snippet below).

For another example, it'southward mentioned that the elements in a set need to exist hashable.

You may wonder — What does hashable mean exactly? Which objects are hashable and which are not? What will happen if we use unhashable objects as keys for dictionaries? Then on. Many related questions can be asked.

In this commodity, we'll get over some key points virtually hashability such that you'll learn how to accost these questions. In the finish, yous'll probably observe out that these questions are really non hard at all, unlike what you may accept thought initially.

Which Objects Are Hashable and Which Are Not?

Before we brainstorm any mechanistic explanation, the kickoff question that nosotros want to accost is which objects are hashable and which are not.

Because we know that Python explicitly requires that the elements in a set should exist hashable, nosotros tin exam an object'south hashability by just trying to add the object to a set. Successful insertion indicates the objects being hashable and vice versa.

                >>>                  # Create an empty set object                  
>>> elements = set()
>>>                  
>>>                  # The list of objects with each to exist inserted to the prepare                  
>>> items = [1, 0.i, 'ab', (2, 3), {'a': 1}, [1, 2], {two, 4}, None]              

As shown in the higher up code, I created a gear up variable chosen elements and a list variable called items, which includes the well-nigh commonly used built-in data types: int, float, str, tuple, dict, list, set, and NoneType.

The experiment that I'll run is to add together each of the items to the elements. I won't use the for loop in this case, because whatever possible TypeError will stop the iteration. Instead, I'll but call back individual items using indexing.

As you can encounter in the to a higher place lawmaking snippet, here's a quick summary of the experiment's results.

Answer to the section'south question

• Hashable data types: int, float, str, tuple, and NoneType.
• Unhashable data types: dict, list, and ready.

If you're completely new to Python programming, you may take noticed that these three unhashable data types are all mutable in nature, while these 5 hashable data types are all immutable.

In essence, these mutable data are objects whose values can be inverse later their creation, while the values of immutable objects can't be changed afterwards the creation.

Data mutability is a standalone topic that I have covered previously in my other article.

What Does Hashable Mean?

You at present take some ideas about which objects are hashable and which are not, just what does hashable mean, exactly?

Actually, you lot may have heard many like estimator terminologies related to hashable, such as hash value, hashing, hash table, and hashmap. At their core, they share the same fundamental procedure — hashing.

Full general process of hashing (Wikipedia, Public Domain)

The above diagram shows you the general process of hashing. We starting time with some raw information values (termed keys in the figure).

A hash function, which is sometimes termed a hasher, volition bear out specific computations and output the hash values (termed hashes in the figure) for the raw data values.

Hashing and its related concepts crave a whole volume to get clarified, which is beyond the telescopic of the current commodity. However, some important aspects have been discussed briefly in my previous article.

Here, I'll just highlight some central points that are relevant to the present word.

1. The hash function should be computationally robust such that different objects should take different hash values. When different objects accept the same hash value, a collision occurs (equally shown in the effigy above) and should exist handled.
2. The hash function should be consistent such that the same objects volition always lead to the same hash values.

Python has implemented its built-in hash role that produces hash values for its objects. Specifically, nosotros can retrieve an object's hash value by using the built-in hash() function. The following code shows you some examples.

As shown above, we were able to get the hash values — integer numbers for the int and tuple objects.

However, neither the list object nor the dict object had hash values. These results are consistent with the distinction that we're making between hashable and unhashable objects in the final section.

Reply to the department's question

• Hashable: A characteristic of a Python object to indicate whether the object has a hash value, which allows the object to serve equally a primal in a lexicon or an element in a set.

How Can We Customize Hashability?

The flexibility of Python as a general-purpose programming language mainly comes from its support of creating custom classes. With your ain classes, many related data and operations can exist grouped in a much more than meaningful and readable way.

Chiefly, Python has evolved to exist smart enough to make our custom objects hashable by default in most cases.

Consider the following instance. Nosotros created a custom class, Person, which would allow u.s.a. to create instances past specifying a person'southward name and social security number.

Notably, we overrode the default __repr__() function using the f-string method, which would permit us to display the object with more readable data, as shown in the terminal line of the code snippet.

Every bit shown in the above code, we can find out the hash value for the created object person0 past using the born hash() part. Importantly, nosotros're able to include the person0 object as an element in a prepare object, which is good.

Nevertheless, what will happen if nosotros desire to add together more Person instances to the set? A more complicated, but probable scenario is that we construct multiple Person objects of the same person and try to add them to the set object.

Encounter the following code. I created another Person instance, person1, which has the same proper noun and social security number — essentially the same natural person.

Yet, when we added this person to the set object, persons, both Person objects are in the set, which nosotros would non want to happen.

Because, by blueprint, we desire the set object to shop unique natural persons. Consistent with both persons included in the set object, nosotros plant out that these two Person instances are indeed different.

I'll testify you lot the code of how nosotros can brand the custom grade Person smarter so that information technology knows which persons are the same or unlike, for that matter.

In the above code, we updated the custom class Person by overriding the __hash__ and __eq__ functions.

We have previously mentioned that the __hash__() function is used to calculate an object's hash value. The __eq__() function is used to compare the object with another object for equality and it's besides required that objects that compare equal should have the same hash value.

By default, custom form instances are compared past comparing their identities using the congenital-in id() function (learn more nigh the id() role past referring to this commodity).

With the updated implementation, we can encounter that when nosotros were trying to create a set object that consisted of the two Person objects, the __hash__() part got called such that the set object only kept the objects of unique hash values.

Another matter to note is that when Python checks whether the elements in the set object accept unique hash values, it will make sure that these objects aren't equal equally well by calling the __eq__() office.

Answer to the section'south question

Customization: To provide customized behaviors in terms of hashability and equality, nosotros need to implement the __hash__ and __eq__ functions in our custom classes.

Conclusion

In this article, we reviewed the concepts of hashable/hashability in Python.

Specifically, past addressing the three important questions, I promise that y'all accept a improve understanding of hashability in Python. When it'due south applicable, you can implement tailored hashability behaviors for your own custom classes.

cheongcheokhonganscialtat.blogspot.com

Source: https://betterprogramming.pub/3-essential-questions-about-hashable-in-python-33e981042bcb

Share this post