Introduction: Python hash() Function
When working with Python, there are situations where you need a unique numeric value to represent an object. Whether you’re storing data in dictionaries, working with sets, or comparing immutable objects efficiently, generating a hash value plays an important role.
Without a built-in solution, creating consistent numeric identifiers for objects would require additional logic, making programs more complex and less efficient.
A simple and efficient solution to these situations is the Python hash() Function.
What it is: The hash() function is a built-in Python function that returns the hash value of an object. Hash values are integers that Python uses internally for fast lookups in hash-based collections such as dictionaries and sets. Only hashable (immutable) objects can be passed to this function.
Take a look at a quick example to see how it works.
You can also explore its real-world use cases to learn where it is commonly used.
Now let’s explore its syntax, parameters, return value, and practical examples.
💡 Tip: The hash() function plays an important role in Python by enabling fast lookups in dictionaries and sets. To explore more built-in functions with clear explanations and practical examples, visit the
Python Built-in Functions Learning Guide.
Syntax, Parameters, Return Values and Examples: Python hash() Function
The following section explains the syntax, parameters, return value, and a quick example of the Python hash() Function.
Syntax
hash(object)
Parameters
| Parameter | Description |
|---|---|
object |
The hashable object whose hash value is to be generated. |
Return Values
| Return Value | Description |
|---|---|
int |
Returns an integer representing the hash value of the given object. |
Quick Example
The following example generates the hash value of a string.
result = hash("Python")
print(result)
# Sample Output:
-6823746508172453901
The hash() function returns an integer that uniquely represents the given object during the current Python session. The exact value may differ between program executions.
How the Python hash() Function Works
- The
hash()function accepts a single hashable object. - It computes and returns an integer hash value for that object.
- Equal immutable objects always produce the same hash value within a program.
- Hash values help Python perform fast lookups in dictionaries and sets.
- Mutable objects such as lists, dictionaries, and sets cannot be hashed.
Examples: Python hash() Function
The following examples show how the Python hash() Function works in different programming scenarios.
Example 1: Generating the Hash Value of a String
result = hash("Python")
print(result)
# Sample Output:
-6823746508172453901
Explanation: The string "Python" is passed to hash(), which returns an integer representing its hash value. The exact number may vary between different program executions.
Example 2: Hashing an Integer
number = 100
print(hash(number))
# Output:
100
Explanation: Immutable numeric values are hashable. In this case, the integer already has a valid hash value, so hash() returns it directly.
Example 3: Comparing Hash Values of Equal Objects
text1 = "Python"
text2 = "Python"
print(hash(text1))
print(hash(text2))
# Sample Output:
-6823746508172453901
-6823746508172453901
Explanation: Since both variables contain the same immutable string, they produce identical hash values during the same Python session.
Example 4: Hashing a Tuple
data = (10, 20, 30)
print(hash(data))
# Sample Output:
3952409569436607343
Explanation: Tuples are immutable, making them hashable. The function generates a single hash value that represents the entire tuple.
Example 5: Using Hash Values as Dictionary Keys
student = "Alice"
student_hash = hash(student)
records = {
student_hash: "Present"
}
print(records)
# Sample Output:
{-1234567890123456789: 'Present'}
Explanation: The generated hash value is used as a dictionary key. Although Python normally hashes keys automatically, this example shows how the returned hash value can also be stored and reused explicitly.
Example 6: Hashing User Input
text = input("Enter a word: ")
print(hash(text))
# Sample Output:
Enter a word: Python
-6823746508172453901
Explanation: After the user enters a word, hash() generates its hash value and displays the resulting integer.
Example 7: Handling an Unhashable Object
try:
numbers = [1, 2, 3]
print(hash(numbers))
except TypeError as e:
print(e)
# Output:
unhashable type: 'list'
Explanation: Lists are mutable objects, so Python does not allow them to be hashed. Attempting to pass a list to hash() raises a TypeError, which is handled here using a try-except block.
Use Cases: When to use the hash() Function
Below are some common situations where the Python hash() Function becomes useful:
- Generating hash values for immutable objects.
- Working with dictionaries and sets.
- Comparing immutable objects efficiently.
- Creating lookup tables and caches.
- Implementing hashing-based algorithms.
- Inspecting whether an object is hashable.
Key Takeaways: hash() Function
Before wrapping up, here are the key points to remember about the Python hash() Function:
- The
hash()function returns the hash value of a hashable object. - It accepts a single hashable object as its argument.
- The returned hash value is always an integer.
- Immutable objects such as strings, integers, tuples, and frozensets are hashable.
- Mutable objects such as lists, dictionaries, and sets cannot be hashed.
- Python uses hash values internally to perform fast lookups in dictionaries and sets.
In short, the Python hash() Function provides a fast and reliable way to generate hash values for immutable objects, helping Python perform efficient lookups and manage hash-based collections.