Python programmers use hashing to change into enter information right into a fixed-size worth. This worth represents the knowledge uniquely, and the hashing methodology makes it simple to transmit and retailer quite a lot of types of information securely.

Hashing protects information from unauthorized get admission to and tampering. It’s an crucial component in information integrity and safety use instances.

This newsletter explores the whole thing you wish to have to learn about hashing in Python. It dives into hashing makes use of and highlights quite a lot of hashing algorithms that make your code extra environment friendly, safe, and dependable.

What Is Hashing in Python?

Hashing converts enter information, equivalent to a string, document, or object, right into a fixed-size string of bytes. The hash or digest represents the enter in a singular and reproducible means.

Hashing performs an important function in detecting information manipulation and adorning safety. It may compute a hash worth for a document, message, or different piece of information. An software shops the hash securely to ensure later that the knowledge has no longer been tampered with.

Probably the most not unusual makes use of of hashing in safety is password garage. Hashing is a viable selection to storing simple textual content passwords in a database. When a consumer enters their password, the gadget hashes it sooner than storing it within the database. If a hacker accesses the database, they’ll to find that the password is tricky to thieve.

Python hashing purposes make all this conceivable. Those mathematical purposes let an software manipulate information into hash values.

How To Make an Efficient Hashing Serve as

A hashing serve as will have to meet the next standards to be efficient and secure:

  • Deterministic — Given the similar enter, the serve as will have to all the time go back the similar output.
  • Environment friendly — It will have to be computationally environment friendly when calculating the hash worth of any given enter.
  • Collision resistant — The serve as will have to decrease the danger of 2 inputs making the similar hash worth.
  • Uniform — The serve as’s outputs will have to be uniformly dispensed around the vary of conceivable hash values.
  • Non-invertible — It will have to be not going for a pc to calculate the serve as’s enter worth in line with the hash worth.
  • Non-predictable — Predicting the serve as’s outputs will have to be difficult, given a suite of inputs.
  • Delicate to enter adjustments — The serve as will have to be delicate to minor variations in enter. Slight adjustments will have to motive a large distinction within the ensuing hash worth.

Hashing Use Instances

After getting an good enough hashing serve as with these kinds of traits, you’ll be able to use it on quite a lot of use instances. Hashing purposes paintings smartly for:

  • Password garage — Hashing is likely one of the very best tactics to retailer consumer passwords in fashionable methods. Python combines quite a lot of modules to hash and safe passwords sooner than storing them in a database.
  • Caching — Hashing shops a serve as’s output to avoid wasting time when calling it later.
  • Information retrieval — Python makes use of a hash desk with a integrated dictionary information construction to temporarily retrieve values through key.
  • Virtual signatures — Hashing can examine the authenticity of messages that experience virtual signatures.
  • Report integrity exams — Hashing can test a document’s integrity all over its switch and obtain.

Python’s Constructed-In Hashing Serve as

Python’s integrated hashing serve as, hash(), returns an integer worth representing the enter object. The code then makes use of the ensuing hash worth to decide the thing’s location within the hash desk. This hash desk is an information construction that implements dictionaries and units.

The code underneath demonstrates how the hash() serve as works:

my_string = "hi international"

# Calculate the hash worth of the string
hash_value = hash(my_string)

# Print the string and its hash worth
print("String: ", my_string)
print("Hash worth: ", hash_value)

If we save that code in a document named, we will execute it (and notice the output) like this:

% python3
String:  hi international
Hash worth:  2213812294562653681

Let’s run that once more:

% python3
String:  hi international
Hash worth:  -631897764808734609

The hash worth is other when invoked a 2d time as a result of fresh releases of Python (variations 3.3 and up), through default, follow a random hash seed for this serve as. The seed adjustments on every invocation of Python. Inside a unmarried example, the consequences will probably be equivalent.

As an example, let’s put this code in our document:

my_string = "hi international"

# Calculate 2 hash values of the string
hash_value1 = hash(my_string)
hash_value2 = hash(my_string)

# Print the string and its hash values
print("String: ", my_string)
print("Hash worth 1: ", hash_value1)
print("Hash worth 2: ", hash_value2)

When done, we see one thing like this:

String: hi international
Hash worth 1:  -7779434013116951864
Hash worth 2:  -7779434013116951864

Barriers of Hashing

Even though Python’s hash serve as is promising for quite a lot of use instances, its boundaries make it incorrect for safety functions. Right here’s how:

  • Collision assaults — A collision happens when two other inputs produce the similar hash worth. An attacker may use the similar input-making solution to bypass safety features that depend on hash values for authentication or information integrity exams.
  • Restricted enter length — Since hash purposes produce a fixed-sized output irrespective of the enter’s length, an enter better in length than the hash serve as’s output may cause a collision.
  • Predictability — A hash serve as will have to be deterministic, giving the similar output each time you give you the similar enter. Attackers would possibly make the most of this weak spot through precompiling hash values for lots of inputs, after which evaluating them to focus on worth hashes to discover a fit. This procedure is known as a rainbow desk assault.

To forestall assaults and stay your information secure, use safe hashing algorithms designed to withstand such vulnerabilities.

The usage of hashlib for Protected Hashing in Python

As an alternative of the usage of the integrated Python hash(), use hashlib for extra safe hashing. This Python module gives a lot of hash algorithms to hash information securely. Those algorithms come with MD5, SHA-1, and the extra safe SHA-2 circle of relatives, together with SHA-256, SHA-384, SHA-512, and others.


The commonly used cryptographic set of rules MD5 finds a 128-bit hash worth. Use the code like that underneath to generate an MD5 hash the usage of the hashlib‘s md5 constructor:

import hashlib

textual content = "Hi Global"
hash_object = hashlib.md5(textual content.encode())

The output of the above (in our document) will probably be constant throughout invocations:


Observe: The hexdigest() manner within the code above returns the hash in a hexadecimal structure secure for any non-binary presentation (equivalent to electronic mail).


The SHA-1 hash serve as secures information through creating a 160-bit hash worth. Use the code underneath with the sha1 constructor for the hashlib module’s SHA-1 hash:

import hashlib

textual content = "Hi Global"
hash_object = hashlib.sha1(textual content.encode())

The output of the above:



There are quite a lot of hash choices within the SHA-2 circle of relatives. The hashlib SHA-256 constructor generates a extra safe model in that circle of relatives with a 256-bit hash worth.

Programmers frequently use SHA-256 for cryptography, like virtual signatures or message authentication codes. The code underneath demonstrates the best way to generate a SHA-256 hash:

import hashlib

textual content = "Hi Global"
hash_object = hashlib.sha256(textual content.encode())

The output of the above:



SHA-384 is a 384-bit hash worth. Programmers frequently use the SHA-384 serve as in packages wanting extra information safety.

In line with the former examples, you’ll be able to most certainly bet that this can be a observation that may generate a SHA-384 hash:

hash_object = hashlib.sha384(textual content.encode())


SHA-512 is essentially the most safe member of the SHA-2 circle of relatives. It makes a 512-bit hash worth. Programmers use it for high-throughput packages, equivalent to checking information integrity. The code underneath presentations the best way to generate a SHA-512 hash with the hashlib module in Python:

hash_object = hashlib.sha512(textual content.encode())

How To Select a Hashing Set of rules

Since those algorithms range, choose your hashing set of rules in line with your use case and its safety necessities. Listed below are some steps to apply:

  • Perceive the use case — Your use case determines what sort of set of rules to make use of. As an example, when storing delicate information equivalent to passwords, your hashing set of rules will have to give protection to in opposition to brute-force assaults.
  • Believe your safety necessities — Your use case’s safety necessities rely on the kind of information you plan to retailer, they usually decide what sort of set of rules to pick out. As an example, a strong hashing set of rules is very best for storing extremely delicate knowledge.
  • Analysis the to be had hashing algorithms — Discover every hashing kind to grasp its strengths and weaknesses. This knowledge is helping you choose the most suitable choice to your use case.
  • Overview the chosen hashing set of rules — As soon as you select a hashing set of rules, evaluation whether or not it meets your safety necessities. This procedure would possibly contain trying out it in opposition to recognized assaults or vulnerabilities.
  • Put in force and take a look at the hashing set of rules — In any case, put into effect and take a look at the set of rules totally to verify it purposes appropriately and securely.

How To Use Hashing for Password Garage

Hashing has very good possible for storing passwords, a crucial part of cybersecurity.

Preferably, the appliance hashes and shops passwords in a safe database to forestall unauthorized get admission to and information breaches. On the other hand, hashing by myself is probably not sufficient to offer protection to the guidelines. Hashed passwords are nonetheless prone to brute power and dictionary assaults. Hackers frequently use those practices to bet passwords and achieve unauthorized get admission to to accounts.

A extra safe means to make use of hashing for password garage comes to the salting methodology. Salting provides distinctive, random strings or characters to every password sooner than hashing it. The salt is exclusive to every password, and the appliance shops it along the hashed password within the database.

Each and every time a consumer logs in, the appliance retrieves the salt from the database, provides it to the entered password, after which hashes the blended salt and password.

If an attacker features get admission to to the database, they should compute the hash for every password and every conceivable salt worth. Salting makes those assaults extra complicated, so it’s a useful approach to deter dictionary assaults.

Python’s secrets and techniques module makes salting simple. This module generates random salts, securely storing passwords and managing tokens and cryptographic keys.

The code underneath makes use of the hashlib library and secrets and techniques module to safe consumer passwords additional:

import hashlib
import secrets and techniques

# Generate a random salt the usage of the secrets and techniques module
salt = secrets and techniques.token_hex(16)

# Get the consumer's password from enter
password = enter("Input your password: ")

# Hash the password the usage of the salt and the SHA-256 set of rules
hash_object = hashlib.sha256((password + salt).encode())

# Get the hexadecimal illustration of the hash
hash_hex = hash_object.hexdigest()

# Retailer the salt and hash hex for your database

How To Use Hashing for Information Integrity Tests

Hashing additionally is helping test information integrity and give protection to transmitted information from amendment and tampering. This four-step methodology makes use of a cryptographic hash serve as to provide the document a singular hash worth.

First, choose the proper hash serve as and use it to generate a hash worth for the enter information. Retailer that hash worth, then use it for comparability when wanted. Every time you wish to have to ensure the knowledge’s integrity, the appliance generates the hash worth of the present information the usage of the similar hash serve as. Then, the appliance compares the brand new hash worth with the saved worth to verify they’re equivalent. If that is so, the knowledge is uncorrupted.

The hashed worth is exclusive, or even a tiny exchange within the enter information triggers a considerably other hash worth. This makes it simple to come across any unauthorized adjustments or changes to the transmitted information.

The stairs underneath display the usage of a hash serve as for information integrity exams.

Step 1: Import the hashlib Module

import hashlib

Step 2: Use a hashlib Hash Set of rules

def generate_hash(file_path):

    # Open the document in binary mode
    with open(file_path, "rb") as f:

        # Learn the contents of the document
        contents = f.learn()

        # Generate the SHA-256 hash of the contents
        hash_object = hashlib.sha256(contents)

        # Go back the hexadecimal illustration of the hash
        go back hash_object.hexdigest()

Step 3: Name the Serve as and Move within the Report Trail

file_path = "trail/to/my/document.txt"
hash_value = generate_hash(file_path)

Step 4: Generate Hashes for the Authentic Report and Transmitted or Changed Report

# Generate the hash of the unique document
original_file_path = "trail/to/my/document.txt"
original_file_hash = generate_hash(original_file_path)

# Transmit or regulate the document (for instance, through copying it to another location)
transmitted_file_path = "trail/to/transmitted/document.txt"

# Generate the hash of the transmitted document
transmitted_file_hash = generate_hash(transmitted_file_path)

Step 5: Evaluate the Two Hashes

if original_file_hash == transmitted_file_hash:
    print("The document has no longer been tampered with")
    print("The document has been tampered with")


Hashing is beneficial for information integrity and password safety. You get essentially the most out of a hashing serve as while you put into effect safe hashing ways, equivalent to the usage of the hashlib module and salting.

Those ways lend a hand save you rainbow assaults, collision assaults, and different safety vulnerabilities that impact hashing. Programmers frequently use those ways with hashing purposes in Python to verify the knowledge integrity of information and retailer passwords securely.

Now that you just’ve realized extra about hashing ways in Python use them to give a boost to your personal software’s safety. Discover extra Python articles at the Kinsta weblog to develop your experience, after which imagine deploying your subsequent Python software on Kinsta’s Utility Website hosting platform.

The put up What You Want To Know About Hashing in Python seemed first on Kinsta®.

WP Hosting

[ continue ]