Random Password Generator in Python

In the following tutorial, we will build a Random Password Generator in Python. The "Random Password Generator" is a program that will generate strong random passwords of the specified length with the help of the alphabet, numbers, and symbols. Let us first understand the prerequisites and build the intuition of the program so that the implementation can become simpler.

But before we start, a good knowledge of Python programming language is necessary, along with a clear understanding of the random module and data structures to build a random password generator in Python.

We will be utilizing the following:

The string data structure,
The list data structure,
Loops (The for loop and while loop)

We will mainly use the random module - A built-in Python module to generate random objects. We will utilize various methods of the random module in order to randomly select the letters of the password from the list of alphabets, numbers, and symbols.

Moreover, a fundamental understanding of the Tkinter module and its related method will be very useful while implementing the Graphical User Interface (GUI) approach of building a Random Password Generator in Python.

Let us now head on to understand the complete concept and the steps required for the development of a Random Password Generator in Python.

Understanding the Concept of developing a Random Password Generator

The concept behind developing a "Random Password Generator in Python is quite easy, and its implementation is divided into different steps shown below:

Step 1: First of all, we will create a string or list containing all the alphabets (both in small and capital letters), numbers, and symbols.

Step 2: Secondly, we will accept the length of the required password as input from the user.

Step 3: At last, we will use a loop iterating from 0 to the length of the password, and in every iteration, we will randomly select a letter from the set of letters defined above and store them into a resultant password.

Let us refer to the following section for better clarity and implementation:

Sample Output

Suppose the user inputs the length of the required password as 8; then one of the randomly generated passwords will appear as shown below:

Output:

A randomly generated Password is: iE@g#Jq0

Understanding the Requirements of the Project

In order to build a Random Password Generator in Python, we will require a good understanding of Programming in Python, such as the working of operators, loops, and functions. We will also use some data structures such as strings, lists, and more.

Moreover, we will use different methods of the Python random module that will allow us to select among different values randomly. Some of the most important methods of the random module are randint(), sample(), seed(), choice(), and many more.

If the following Random Password Generator program is, we will make use of some methods of the random module. Let us briefly discuss them before implementing them in the program.

choice(): The choice() method is considered one of the effective methods of the random module. This method is used to select a random value (or data element) from the given sequence. This sequence can be any sequential data type, such as strings, lists, tuples, or any other sequence of numbers or objects.
sample(): The sample() method is utilized to acquire a sequence of randomly chosen values from the given input sequence. The sample() method is used to return a list of unique options. The sample() method accepts two arguments. The first argument is the original sequence from which the random sequence output must be generated. The second one is the length of the random sample that must be generated.

In this tutorial, we will also use the Python Tkinter module to adapt a GUI (Graphical User Interface) for the program.

Since both the modules are preinstalled as the Standard libraries of Python, there is no need to install them externally.

So, let us get straight into the implementation part of the project.

Steps to Build the Random Password Generator in Python

The following are the steps to implement the random password generator in Python:

Step 1: Firstly, we will import the required modules.

Step 2: We will define a function to generate a password using all alphanumeric characters.

Step 3: We will update the program to accept the password length as the user input.

Step 4: We will update the program again to generate multiple passwords.

Step 5: Finally, we will integrate Graphical User Interface (GUI) in the Password Generator using Tkinter.

Let us now understand the implementation of the above steps in detail.

Importing the Required Modules

We will start by importing the random module.

The following is the snippet of code demonstrating the same.

File: passGen.py

# importing the necessary modules
import random                       # importing the random module

Explanation:

In the above snippet of code, we have imported the random module.

Defining a Function to Generate the Password using All Alphanumeric Characters

Now that we have imported all the necessary modules in the program, it is time to start defining a function that will allow us to generate the password with the help of all alphanumeric characters.

Step 1: We will start by defining a function that will return a randomly generated password. This function will accept one parameter signifying the length of the password to be generated.

Step 2: We will create a string or list containing all the alphabets (small and capital letters), numbers, and symbols.

Step 3: We will initialize an empty string to store the randomly chosen password.

Step 4: At last, we will run a loop iterating from 0 to the length of the password. We will randomly select a character from the character list with the help of the random.choice() method and add the selected character to the password string. Finally, we will return the password string.

Let us consider the following snippet of code illustrating the same.

File: passGen.py

# importing the necessary module
import random                       # importing the random module

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"
    # defining an empty password string
    pass_str = ""

    # creating a loop to randomly select the character from the list and insert it in the password string upto the given length
    for i in range(len):
        # using the random.choice() method to select a random character from the list and inserting it in the password string
        pass_str = pass_str + random.choice(list_of_chars)
    
    # returning the generated password string
    return pass_str

# main function
if __name__ == "__main__":
    # defining the length of the password
    len = 8
    # calling the generate_password() function and storing the returned value in a variable
    pass_str = generate_password(len)
    # printing the final result for the users
    print("A randomly generated Password is:", pass_str)

Output:

A randomly generated Password is: &xCC@5X)

Explanation:

As we can observe in the above output, the generated password has some repeated character(s). However, we can generate a password consisting of a unique character with the help of the sample() method of the random module. The sample() method only selects unique value(s) from the given sequence. The length of the required password sequence can be specified later. Therefore, we will provide the value of len into the sample() method so that we don't require to utilize the loop.

Let us consider the following snippet of code illustrating the implementation of the same for better understanding.

File: passGen.py

# importing the necessary module
import random                       # importing the random module

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"

    # using the random.sample() method to return a list of randomly selected characters from the list of characters.
    selected_char = random.sample(list_of_chars, len)

    # converting the list into the string
    pass_str = "".join(selected_char)
    
    # returning the generated password string
    return pass_str

# main function
if __name__ == "__main__":
    # defining the length of the password
    len = 8
    # calling the generate_password() function and storing the returned value in a variable
    pass_str = generate_password(len)

    # printing the final result for the users
    print("A randomly generated Password is:", pass_str)

Output:

A randomly generated Password is: LAz%^Ugq

Updating the Program to accept the Password Length from the User

Now that we have defined the function, we need to generate a password of a given length, it is time for us to make one adjustment to the program. As observed in the previous program, we have explicitly added the length of the required password. We can also accept the user's password length by using the input() method in Python.

Let us consider the following snippet of code illustrating the same.

File: passGen.py

# importing the necessary module
import random                       # importing the random module

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"

    # using the random.sample() method to return a list of randomly selected characters from the list of characters.
    selected_char = random.sample(list_of_chars, len)

    # converting the list into the string
    pass_str = "".join(selected_char)
    
    # returning the generated password string
    return pass_str

# main function
if __name__ == "__main__":
    # using the input() method to ask the user to input the length of the Password as integer
    len = int(input("Enter the length of the Password: "))

    # calling the generate_password() function and storing the returned value in a variable
    pass_str = generate_password(len)

    # printing the final result for the users
    print("A randomly generated Password is:", pass_str)

Output:

Enter the length of the Password: 8 
A randomly generated Password is: Fa!wH67X

Updating the Program to Generate Multiple Passwords

We will now update the program once again to generate multiple passwords using the same logic as discussed earlier.

To generate more than one random password, we can add an infinite loop to the program that will accept the length of the required password and produce the password. We can ask a simple question asking the user whether they want to generate a password or exit the program.

Let us consider the following snippet of code demonstrating the same.

File: passGen.py

# importing the necessary module
import random                       # importing the random module

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"

    # using the random.sample() method to return a list of randomly selected characters from the list of characters.
    selected_char = random.sample(list_of_chars, len)

    # converting the list into the string
    pass_str = "".join(selected_char)
    
    # returning the generated password string
    return pass_str

# main function
if __name__ == "__main__":
    # creating an infinite loop
    while True:
        # asking user for their selection
        userSelection = input("Do you wish to generate a Password?\nPress 'Y/y' to Continue, or 'N/n' to Exit: ")
        # if the user does not want continue
        if userSelection == 'N' or userSelection == 'n':
            # printing a message
            print("Thank You! See you next time.")

            # breaking the loop
            break

        # if the user wants to continue
        elif userSelection == 'Y' or userSelection == 'y':
            # using the input() method to ask the user to input the length of the Password as integer
            len = int(input("Enter the length of the Password: "))

            # calling the generate_password() function and storing the returned value in a variable
            pass_str = generate_password(len)

            # printing the final result for the users
            print("A randomly generated Password is:", pass_str)
            print("") # one line spacing

        # if the user enters wrong input
        else:
            # printing a message
            print("Invalid Input! Try Again.")
            print("") # one line spacing

Output:

Do you wish to generate a Password?
Press 'Y/y' to Continue, or 'N/n' to Exit: Y
Enter the length of the Password: 8  
A randomly generated Password is: Pm@p^#61

Do you wish to generate a Password?
Press 'Y/y' to Continue, or 'N/n' to Exit: y
Enter the length of the Password: 12
A randomly generated Password is: *5&7MAOdrz)Q

Do you wish to generate a Password?
Press 'Y/y' to Continue, or 'N/n' to Exit: w
Invalid Input! Try Again.

Do you wish to generate a Password?
Press 'Y/y' to Continue, or 'N/n' to Exit: Y
Enter the length of the Password: 10
A randomly generated Password is: )w1veSlXsP

Do you wish to generate a Password?
Press 'Y/y' to Continue, or 'N/n' to Exit: n
Thank You! See you next time.

Integrating GUI to the Password Generator using Tkinter

Tkinter is a standard Python library used for the development of GUI applications in Python.

The following are the steps we will follow to integrate the GUI into the Password Generator using the Tkinter package:

Step 1: Import the required modules.

Step 2: Define the necessary functions.

Step 3: Create the main window for the application.

Step 4: Add the Widgets to the window.

Step 5: Running the Application.

Let us understand the above steps in detail.

Importing the Necessary Modules

We will import the random module along with the modules and widgets from the Tkinter module. Apart from these modules, we must import the messagebox module from Tkinter. The messagebox module is utilized to display any error, warning, and important message in a message box.

Let us consider the following snippet of code to understand the implementation of the same.

File: main.py

# importing the necessary modules
import random                           # importing the random module
import tkinter as tk                    # importing the tkinter module
from tkinter import *                   # importing everything from tkinter
from tkinter import messagebox as mb    # importing messagebox module from tkinter

Explanation:

In the above snippet of code, we have imported the random module. We have also imported everything from the Tkinter package. We have then imported the messagebox module as mb from the Tkinter package.

Defining the Required Functions

Now that we have imported the required modules, we must define the functions necessary to implement different operations in the application. We will define functions to generate the password, check if the selection is appropriate, retrieve the length of the password, and reset everything in the application.

Let us understand the implementation of these functions in detail.

Function to Generate the Password

We will start by defining a function to generate the password for the given length. Since we have already defined this function, we will make some slight adjustments to it so that it can display the generated password string in the label.

Let us consider the following snippet of code illustrating the same.

File: main.py

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"

    # using the random.sample() method to return a list of randomly get_length characters from the list of characters.
    selected_char = random.sample(list_of_chars, len)

    # converting the list into the string
    pass_str = "".join(selected_char)
    
    # displaying the generated password string in the label
    pass_label.config(text = pass_str)

    # printing the password string in command line
    print("Generated Password is :", pass_str, "\n")

Explanation:

In the above snippet of code, we have updated the generate_password() function to display the generated password string in the label using the config() method on the defined label widget. We have also printed the generated string in the command line using the print() method.

Function to Check the User Selection

We will now define a function that will check if the user has made any selection from the given choices. This function will retrieve the current length value of the password and pass it to the function to generate the length-specific password if it is not equal to the initial value.

Let us consider the following snippet of code to understand the implementation of the same.

File: main.py

# defining a function to check if the user has selected any option
def selection():
    '''This function will check if the user has selected
    any option and call the generate_password() function
    by passing the appropriate length'''

    # retrieving the length of the password
    len = length.get()
    # if the length is not 0 calling the generate_password(len) function
    if len != 0:
        generate_password(len)
    # else displaying the error message using the messagebox's showerror() method
    else:
        mb.showerror("Invalid Selection", "Length of Password is not defined.")

Explanation:

In the above snippet of code, we defined a function as selection(). Inside this function, we have retrieved the password length using the get() method on the object of the IntVar() class. We have then compared the current value of the length to its initial value using the if-else conditional statement. If the length is not 0 (initial value), we have called the generate_password() method by passing the length as the function's argument; otherwise, a message box will pop up indicating the error which we have implemented using the showerror() method of the Tkinter's messagebox modules.

Function to Retrieve the Password's Length

We will now define a function to retrieve the length of the password. This is an optional function that we will use to print the selected password length in the command line. This function will also help us enable the toggle functionality of the radio buttons.

Let us consider the following snippet of code demonstrating the same.

File: main.py

# defining a function to retrieve the length of the password
def get_length():
    '''This function will retrieve the length of the password
    from the selected option and print it in Command Line'''

    # printing the selected length of the password for the user 
    print("Selected Length of Password :", length.get(), "characters")

Explanation:

In the above snippet of code, we defined a function as get_length(). Within this function, we have printed the selected length of the password using the print() method.

Function to Reset Everything in the Application

The last function we define will allow us to reset everything in the application. This function will clear the generated password from the label and deselect any selected radio button in the application.

Let us consider the following snippet of code illustrating the same.

File: main.py

# defining a function to reset everything
def reset():
    "This function will reset everything in the application"

    # setting the initial value of the password's length
    length.set(0)
    # setting the initial value of the label
    pass_label.config(text = "")

Explanation:

In the above snippet of code, we have defined a function as reset(). Within this function, we have set the initial value of the password's length in the object of the IntVar() class. We have also used the config() method to configure the initial text in the label.

Creating the Main Window Screen of the Application

Now that we have defined all the necessary functions that we will need to implement different operations in the application, it is time for us to create a main window screen. To accomplish this goal, we will create an object of the Tk() class of the tkinter module. This class will create a GUI window screen where we can add widgets later. We will also configure the title, size, and position of the created window, along with the background color and an icon.

Let us consider the following snippet of code illustrating the same.

File: main.py

# main function
if __name__ == "__main__":
    # creating a window using the Tk() class
    gui_root = Tk()
    # setting the title of the window
    gui_root.title("Random Password Generator - JAVATPOINT")
    # configuring the size and position of the window
    gui_root.geometry("500x450+400+200")
    # setting the background color of the window
    gui_root.config(bg = "#E6E6FA")
    # setting an icon for the application
    gui_root.iconbitmap("./password.ico")

Explanation:

In the above snippet of code, we have created a window by instantiating the tkinter's Tk() class. We have also set the window's title using the title() method. We have also used the geometry() method to set the size and position of the window. We have then configured the background color to #E6E6FA of the window with the help of the config() method. At last, we have set the icon for the application using the iconbitmap() method.

Adding the Widgets to the Application and setting the event triggers

We will now add the required widgets to the application to trigger different events. We will make use of frames to organize other widgets like labels, buttons, and radio buttons in a proper way.

So, let us understand the addition of these widgets in depth.

Adding Frames

We will start by adding the frames to the main window. These frames will help structure the other widgets. These frames can be created using the Frame() widget of the tkinter module.

Let us consider the following snippet of code demonstrating the same.

File: main.py

# creating some frames
    heading_frame = Frame(gui_root, bg = "#7B68EE")
    radiobtn_frame = Frame(gui_root, bg = "#E6E6FA")
    button_frame = Frame(gui_root, bg = "#E6E6FA")
    result_frame = Frame(gui_root, bg = "#E6E6FA")

    # using the pack() method for the placement of the frames
    heading_frame.pack(fill = "both")
    radiobtn_frame.pack(pady = 10)
    button_frame.pack(pady = 10)
    result_frame.pack(pady = 10)

Explanation:

In the above snippet of code, we have used the Frame() widgets to add the frames to the window. We have also set the master parameter of the first two frames to gui_root, indicating left and right sides of the window. We have configured the background color by setting it as a value for the bg parameter. At last, we have used the pack() method to set the positions of these frames.

Now that we have added the frames to the application, it is time to add the remaining widgets like labels, entry fields, an options menu, buttons, and a table to their respective frame.

Adding the Widgets to the heading_frame Frame

We will start by adding some labels to the first frame, i.e., heading_frame. These labels will include the heading of the application and a subheading illustrating working of the application. We will use the Label() widget of the tkinter module to create the required label.

Let us consider the following snippet of code demonstrating the same.

File: main.py

    # ---------------- Adding widgets to the heading_frame frame ----------------
    # adding the label to display the heading    
    heading = Label(
        heading_frame,
        text = "RANDOM PASSWORD GENERATOR",
        font = ("Bahnschrift SemiBold", "17"),
        bg = "#7B68EE",
        fg = "#FFFFFF"
        )

    # adding the label to display sub-heading
    subheading = Label(
        heading_frame,
        text = "Customize the Length of the Password:",
        font = ("Bahnschrift SemiBold", "14"),
        bg = "#4B0082",
        fg = "#FFFFFF"
        )
    
    # using the pack() method to set the position of the above labels
    heading.pack(pady = 10)
    subheading.pack(fill = "both")

Explanation:

In the above code snippet, we have used the Label() widget to create the required labels. We have then set the master parameter of these labels to the heading_frame frame. We have also specified the text to be displayed, font style, background, and foreground color. At last, we have used the pack() method to set the position of the above labels.

Adding the Widgets to the radiobtn_frame Frame

We will now add some radio buttons to the radiobtn_frame Frame of the window. We will use the Radiobutton() widget of tkinter module. We will also create an object of the IntVar() class where the length of the password will be stored whenever the user selects any radio button.

Let us consider the following snippet of code illustrating the implementation.

File: main.py

    # ---------------- Adding widgets to the radiobtn_frame frame ----------------
    # instantiating the IntVar() class
    length = IntVar()
    # setting an initial value of the IntVar object
    length.set(0)

    # adding some radio buttons to the window
    # 4 Characters Length
    radiobuttonOne = Radiobutton(
        radiobtn_frame,
        text = '4 Characters',
        variable = length,
        value = 4,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 6 Characters Length
    radiobuttonTwo = Radiobutton(
        radiobtn_frame,
        text = '6 Characters',
        variable = length,
        value = 6,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 8 Characters Length
    radiobuttonThree = Radiobutton(
        radiobtn_frame,
        text = '8 Characters',
        variable = length,
        value = 8,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 10 Characters Length
    radiobuttonFour = Radiobutton(
        radiobtn_frame,
        text = '10 Characters',
        variable = length,
        value = 10,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 12 Characters Length
    radiobuttonFive = Radiobutton(
        radiobtn_frame,
        text = '12 Characters',
        variable = length,
        value = 12,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 16 Characters Length
    radiobuttonSix = Radiobutton(
        radiobtn_frame,
        text = '16 Characters',
        variable = length,
        value = 16,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )

    # using the grid() method to set the position of the above radio buttons in grid format
    radiobuttonOne.grid(row = 0, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonTwo.grid(row = 0, column = 1, padx = 10, pady = 2, sticky = W)
    radiobuttonThree.grid(row = 1, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonFour.grid(row = 1, column = 1, padx = 10, pady = 2, sticky = W)
    radiobuttonFive.grid(row = 2, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonSix.grid(row = 2, column = 1, padx = 10, pady = 2, sticky = W)

Explanation:

In the above snippet of code, we created an object of the IntVar() class to store the length of the password and used the set() method to set 0 as its initial value. We have then used the Radiobutton() widgets to create some radio buttons and set the value of their master parameters to radiobtn_frame. We have also customized its content, variable, value, font, background color, and function they will call. At last, we have used the grid() method to set the position of these radio buttons in a grid format.

Adding the Widget to the button_frame Frame

We will now add some buttons to the application to trigger the functions. We can create buttons using the Button() widget of the tkinter module.

Let us consider the following snippet of code illustrating the same.

File: main.py

    # ---------------- Adding widgets to the button_frame frame ----------------    
    # adding some buttons to the window
    # button to generate password 
    get_pass = Button(
        button_frame,
        text = "Get Password",
        font = ("Bahnschrift SemiBold", "12"),
        width = 14,
        bg = "#32CD32",
        fg = "#FFFFFF",
        activebackground = "#006400",
        activeforeground = "#FFFFFF",
        relief = GROOVE,
        command = selection
        )
    # button to clear everything
    clear_all = Button(
        button_frame,
        text = "Reset",
        font = ("Bahnschrift SemiBold", "12"),
        width = 14,
        bg = "#FF0000",
        fg = "#FFFFFF",
        activebackground = "#8B0000",
        activeforeground = "#FFFFFF",
        relief = GROOVE,
        command = reset
        )

    # using the grid() method to set the position of the above buttons in grid format    
    get_pass.grid(row = 0, column = 0, padx = 5, pady = 2)
    clear_all.grid(row = 0, column = 1, padx = 5, pady = 2)

Explanation:

In the above snippet of code, we have used the Button() widgets to create some buttons and set their master parameters to button_frame. We have also configured the text, font style, width, background and foreground colors along with the functions these buttons will call. At last, we have used the grid() method to set the position of these buttons in a grid format.

Adding the Widgets to the result_frame Frame

We will now add a label to display the generated password.

Let us consider the following snippet of code illustrating the same.

File: main.py

    # ---------------- Adding widgets to the result_frame frame ----------------    
    # adding a label to display the generated password 
    pass_label = Label(
        result_frame,
        text = "",
        font = ("Consolas", "15", "bold"),
        bg = "#E6E6FA",
        fg = "#000000"
        )

    # using the pack() method to set the position of the label
    pass_label.pack()

Explanation:

In the above snippet of code, we have created a label using the Label() widget and set its master parameter to result_frame. We initially set its text to an empty string and customized its font style, background, and foreground color. At last, we used the pack() method to set the position of the label.

Running the Application

Now that we have defined all the necessary functions created the main window of the application, and added the required widgets to the window, it is time for us to finally run the application using the tkinter's mainloop() method.

Let us consider the following snippet of code demonstrating the same.

File: main.py

    # using the mainloop() method to run the application
    gui_root.mainloop()

Explanation:

In the above snippet of code, we have called the tkinter's mainloop() method with the gui_root, the object of the Tk() class, to run the application.

Hence, the project code is now complete. We will save this python program file and run the following command in the command prompt or terminal to see the output.

Syntax:

But before we see the output, the complete program code of the 'Random Password Generator' is shown below.

The Complete Program Code of Random Password Generator in Python

The following is the complete program code for the 'Random Password Generator in Python'.

File: main.py

# importing the necessary modules
import random                           # importing the random module
import tkinter as tk                    # importing the tkinter module
from tkinter import *                   # importing everything from tkinter
from tkinter import messagebox as mb    # importing messagebox module from tkinter

# defining a function to randomly generate the password
def generate_password(len):
    "This function accepts a parameter 'len' and returns a randomly generated password"

    # defining the list of characters that will be used to generate the password
    list_of_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"

    # using the random.sample() method to return a list of randomly get_length characters from the list of characters.
    selected_char = random.sample(list_of_chars, len)

    # converting the list into the string
    pass_str = "".join(selected_char)
    
    # displaying the generated password string in the label
    pass_label.config(text = pass_str)

    # printing the password string in command line
    print("Generated Password is :", pass_str, "\n")

# defining a function to check if the user has selected any option
def selection():
    '''This function will check if the user has selected
    any option and call the generate_password() function
    by passing the appropriate length'''

    # retrieving the length of the password
    len = length.get()
    # if the length is not 0 calling the generate_password(len) function
    if len != 0:
        generate_password(len)
    # else displaying the error message using the messagebox's showerror() method
    else:
        mb.showerror("Invalid Selection", "Length of Password is not defined.")

# defining a function to retrieve the length of the password
def get_length():
    '''This function will retrieve the length of the password
    from the selected option and print it in Command Line'''

    # printing the selected length of the password for the user 
    print("Selected Length of Password :", length.get(), "characters")

# defining a function to reset everything
def reset():
    "This function will reset everything in the application"

    # setting the initial value of the password's length
    length.set(0)
    # setting the initial value of the label
    pass_label.config(text = "")

# main function
if __name__ == "__main__":
    # creating a window using the Tk() class
    gui_root = Tk()
    # setting the title of the window
    gui_root.title("Random Password Generator - JAVATPOINT")
    # configuring the size and position of the window
    gui_root.geometry("500x450+400+200")
    # setting the background color of the window
    gui_root.config(bg = "#E6E6FA")
    # setting an icon for the application
    gui_root.iconbitmap("./password.ico")

    # creating some frames
    heading_frame = Frame(gui_root, bg = "#7B68EE")
    radiobtn_frame = Frame(gui_root, bg = "#E6E6FA")
    button_frame = Frame(gui_root, bg = "#E6E6FA")
    result_frame = Frame(gui_root, bg = "#E6E6FA")

    # using the pack() method for the placement of the frames
    heading_frame.pack(fill = "both")
    radiobtn_frame.pack(pady = 10)
    button_frame.pack(pady = 10)
    result_frame.pack(pady = 10)

    # ---------------- Adding widgets to the heading_frame frame ----------------
    # adding the label to display the heading    
    heading = Label(
        heading_frame,
        text = "RANDOM PASSWORD GENERATOR",
        font = ("Bahnschrift SemiBold", "17"),
        bg = "#7B68EE",
        fg = "#FFFFFF"
        )

    # adding the label to display sub-heading
    subheading = Label(
        heading_frame,
        text = "Customize the Length of the Password:",
        font = ("Bahnschrift SemiBold", "14"),
        bg = "#4B0082",
        fg = "#FFFFFF"
        )
    
    # using the pack() method to set the position of the above labels
    heading.pack(pady = 10)
    subheading.pack(fill = "both")

    # ---------------- Adding widgets to the radiobtn_frame frame ----------------
    # instantiating the IntVar() class
    length = IntVar()
    # setting an initial value of the IntVar object
    length.set(0)

    # adding some radio buttons to the window
    # 4 Characters Length
    radiobuttonOne = Radiobutton(
        radiobtn_frame,
        text = '4 Characters',
        variable = length,
        value = 4,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 6 Characters Length
    radiobuttonTwo = Radiobutton(
        radiobtn_frame,
        text = '6 Characters',
        variable = length,
        value = 6,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 8 Characters Length
    radiobuttonThree = Radiobutton(
        radiobtn_frame,
        text = '8 Characters',
        variable = length,
        value = 8,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 10 Characters Length
    radiobuttonFour = Radiobutton(
        radiobtn_frame,
        text = '10 Characters',
        variable = length,
        value = 10,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 12 Characters Length
    radiobuttonFive = Radiobutton(
        radiobtn_frame,
        text = '12 Characters',
        variable = length,
        value = 12,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )
    # 16 Characters Length
    radiobuttonSix = Radiobutton(
        radiobtn_frame,
        text = '16 Characters',
        variable = length,
        value = 16,
        font = ("Times New Roman", "12"),
        bg = "#E6E6FA",
        command = get_length
        )

    # using the grid() method to set the position of the above radio buttons in grid format
    radiobuttonOne.grid(row = 0, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonTwo.grid(row = 0, column = 1, padx = 10, pady = 2, sticky = W)
    radiobuttonThree.grid(row = 1, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonFour.grid(row = 1, column = 1, padx = 10, pady = 2, sticky = W)
    radiobuttonFive.grid(row = 2, column = 0, padx = 10, pady = 2, sticky = W)
    radiobuttonSix.grid(row = 2, column = 1, padx = 10, pady = 2, sticky = W)

    # ---------------- Adding widgets to the button_frame frame ----------------    
    # adding some buttons to the window
    # button to generate password 
    get_pass = Button(
        button_frame,
        text = "Get Password",
        font = ("Bahnschrift SemiBold", "12"),
        width = 14,
        bg = "#32CD32",
        fg = "#FFFFFF",
        activebackground = "#006400",
        activeforeground = "#FFFFFF",
        relief = GROOVE,
        command = selection
        )
    # button to clear everything
    clear_all = Button(
        button_frame,
        text = "Reset",
        font = ("Bahnschrift SemiBold", "12"),
        width = 14,
        bg = "#FF0000",
        fg = "#FFFFFF",
        activebackground = "#8B0000",
        activeforeground = "#FFFFFF",
        relief = GROOVE,
        command = reset
        )

    # using the grid() method to set the position of the above buttons in grid format    
    get_pass.grid(row = 0, column = 0, padx = 5, pady = 2)
    clear_all.grid(row = 0, column = 1, padx = 5, pady = 2)

    # ---------------- Adding widgets to the result_frame frame ----------------    
    # adding a label to display the generated password 
    pass_label = Label(
        result_frame,
        text = "",
        font = ("Consolas", "15", "bold"),
        bg = "#E6E6FA",
        fg = "#000000"
        )

    # using the pack() method to set the position of the label
    pass_label.pack()

    # using the mainloop() method to run the application
    gui_root.mainloop()

Output:

As GUI:

In Command Line:

Selected Length of Password : 10 characters
Generated Password is : $GCfj36r5w

Why Should We Create a Random Password Generator?

A good and strong password is essential in today's world, where data and security are the prime concern. People generally use common passwords that hackers can easily hack to obtain their data.

A better way to learn any programming language is by doing it practically. Especially developing a good beginner project, such as the Random Password Generator in Python, helps us to improve our fundamentals. This project also allows us to understand the use of different standard and external modules of Python.

How to Generate Strong Passwords in Python?

In this tutorial, we have discussed different methods to develop the random password generator in Python. In order to generate a stronger password, we can use the sample() method in place of the choice() method, ensuring no repetition of the digits. We can ask the user to input the number of characters, numbers, and symbols that the user wants in the password.

Let us consider the following example to understand the implementation of the same.

Example:

# importing the random module
import random

# defining a function to randomly generate the password
def password_generator(char_length, num_length, symbol_length):
    '''This function will randomly generate a password on the
    basis of the number of characters, numbers, and symbols'''

    # list of characters, numbers, and symbols
    chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    nums = "0123456789"
    symbols = "!@#$%^&*()"

    # using the random.sample() method to return a list,
    # which we have to convert it into a string before
    # returning it
    selectedChars = random.sample(chars, char_length)
    selectedNums = random.sample(nums, num_length)
    selectedSymbols = random.sample(symbols, symbol_length)

    # creating a list representing the password
    password_list = selectedChars + selectedNums + selectedSymbols
    # using the random.shuffle() method to shuffle the
    # elements of the list so that the numbers, characters,
    # and symbols get shuffled
    random.shuffle(password_list)

    # converting the list into string
    password_str = "".join(password_list)

    # returning the password string
    return password_str

# main function
if __name__ == "__main__":
    # asking the user to input the number of the characters, numbers, and symbols
    char_length = int(input("Enter the Number of the Characters that you need in the password : "))
    num_length = int(input("Enter the Number of the Numbers that you need in the password : "))
    symbol_length = int(input("Enter the Number of the Symbols that you need in the password : "))

    # calling the password_generator() function by passing the number of
    # characters, numbers, and symbols as the required parameters
    password = password_generator(char_length, num_length, symbol_length)

    # printing the generated password for the users
    print("The Randomly Generated Password is :", password)

Output:

Enter the Number of the Characters that you need in the password : 5
Enter the Number of the Numbers that you need in the password : 6
Enter the Number of the Symbols that you need in the password : 5
The Randomly Generated Password is : 1*53Tp%@64B)rV!0

Explanation:

In the above snippet of code, we have imported the random module. We have then defined a function as password_generator() that accepts the length of characters, numbers, and symbols. We have defined a list of characters, numbers, and symbols within this function and used the random.sample() method to randomly select the list of characters, numbers, and symbols up to the given length. We then created a list representing the password and used the random.shuffle() method to shuffle the elements of the list. We then converted the final list into a string containing the required password and returned it. In the main function, we have used the input() method to ask the user the length of the characters, numbers, and symbols required in the password. At last, we have called the password_generator() method by passing all three lengths as the required parameters and printing the generated password for the users.

The Conclusion

The Random Password Generator is a program that is able to generate strong random passwords of the specified length with the combination of alphabets, numbers, and symbols.
In this tutorial, we have learned different ways of developing the Random Password Generator using Python as the programming language.
We have also learned the use of different methods of the random
We have also observed the use of the Tkinter module to create a Graphical User Interface (GUI) for the Random Password Generator.
At last, we have discussed the reason for creating the Random Password Generator and how strong passwords can be generated using this application.

Next Topicre.sub() function in python

← prev next →