Python Tutorial

The Python programming language provides a range of frameworks to work with Graphical User Interface (GUI) applications. The Tkinter or Tk interface is among Python's most commonly utilized interfaces to construct applications based on Graphical User Interface (GUI). Some applications require validation of the text fields to prevent invalid input from the user before the form is submitted. Python enables the validation of the input by allowing the tracing of the variable with the help of a callback function. This function is called when input is added to/deleted from an Entry widget of the Tkinter package.

In the following tutorial, we will learn how to validate the user inputs using the Tkinter package.

So, let's get started.

An Introduction to the Tkinter Validation

Validation in Python Tkinter means declaring the user inputs officially acceptable. In other words, validation is referred to as checking whether the information shared by the user meets the requirements.

There are primarily three types of Validations:

Type Check:This validation is performed to check the data type of the input.
Length Check:This validation is performed to check the minimum or maximum length of the input.
Range Check:This validation is performed to check the range of the input.

The Validation in Python Tkinter depends upon three arguments or parameters that we can utilize for any input widget like the Entry() widget:

validate: This argument is used to denote which type of event will trigger the validation.
validatecommand: This argument is used to check whether the data is valid.
invalidcommand: This argument is executed when the data is invalid. In order words, it will execute if the return value of the validatecommand argument is False.

Let us now briefly understand some basic concepts of these arguments or commands.

The validate argument

The validate argument can be one of the string values as follows:

S. No.	String Value(s)	Description(s)
1	'focus'	This string value validates when the widget gets or loses the focus.
2	'focusin'	This string value validates when the widget gets focus.
3	'focusout'	This string value validates when the widget loses focus.
4	'key'	This string value validates when any keystroke alters the content of the widget.
5	'all'	This string value validates in all the situations mentioned above, like 'focusin', 'focusout', and 'key'.
6	'none'	This string value turns off the validation. This is the default. Note: The string 'none' is not the same as the None value in Python.

The validatecommand argument

The validatecommand argument is a tuple consisting of:

A reference/address to a Tcl/Tk function.
Zero or more substitution codes state the information triggering the event we would like to pass into the function.

We will pass a callable to the widget_name.register() method in order to get a reference to a Tcl/Tk function. This method will return a string we can utilize with the validatecommand option.

Let us consider the following table that displays the substitution codes which we can utilize with the tuple:

S. No.	Substitution Code(s)	Description(s)
1	%d	Action code: 0 for a tried deletion, 1 for a tried insertion, or -1 if the callback function was called for focus in, focus out, or an alteration to the text variable.
2	%i	Whenever the user tries to delete or insert text, this parameter will be the index of the starting of the insertion or deletion. If the callback function were due to focus in, focus out, or an alteration to the parameter, the argument would be -1.
3	%P	The value that the text will have in case the change is permitted.
4	%s	The text in the entry before the change.
5	%S	In case the call was due to deletion or insertion, this argument will be the text being deleted or inserted.
6	%v	The present value of the validate option of the widget.
7	%V	This callback is due to one of the string values, i.e., 'focusin', 'focusout', 'key', or 'forced', if the text variable is altered.
8	%W	The name of the widget.

Let us consider the following example to construct a validatecommand option using the self.validate() method and %P substitution code:

Example:

# an example syntax to construct a validatecommand option that uses the self.validate() method and %P substitution code
validate_cmd = (self.register(self.validate), '%P')

The invalidcommand argument

Similar to validatecommand argument, the invalidcommand argument also requires the utilization of the widget_name.register() method and the substitution code.

Let us consider the following example that returns a tuple by passing into the invalidcommand option:

Example:

# an example syntax that returns a tuple by passing into the invalidcommand option
invalid_cmd = (self.register(self.on_invalid),)

An Example based on Tkinter Validation

In this example, we will create a form consisting of an e-mail input. If the entered e-mail address is invalid, it will display an error message and change the color of the e-mail input. Moreover, we will trigger the validation event when the focus moves out of the entry.

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

Program Code:

# importing the required modules
import tkinter as tk    # importing the tkinter module
from tkinter import ttk # importing the ttk module from tkinter
import re               # importing the re module

# defining the class
class myApplication(tk.Tk):
    # defining an initializing method
    def __init__(self):
        super().__init__()
        # setting up the title of the application
        self.title('Tkinter Validation Form - JAVATPOINT')
        # configuring the size and position of the window
        self.geometry('600x80+400+400')
        # calling the user-defined function to create the widgets
        self.createWidgets()

    # defining the method to create the widgets
    def createWidgets(self):
        # configuring the widget of the columns
        self.columnconfigure(0, weight = 1)
        self.columnconfigure(1, weight = 3)
        self.columnconfigure(2, weight = 1)

        # creating a label using the Label() widget to display the information required to be entered
        self.email = ttk.Label(text = 'E-mail ID:')
        # setting the position of the label in the grid format using the grid() method
        self.email.grid(row = 0, column = 0, padx = 5, pady = 5)

        # creating a validatecommand and invalidcommand options for the email entry field
        validate_cmd = (self.register(self.validate), '%P')
        invalid_vcmd = (self.register(self.on_invalid),)

        # creating an entry field using the Entry() widget for the user to input email address
        self.email_field = ttk.Entry(self, width = 50)
        # configuring the entry field by specifying the values for the validate, validatecommand, invalidcommand parameters
        self.email_field.config(validate = 'focusout', validatecommand = validate_cmd, invalidcommand = invalid_vcmd)
        # setting the position of the entry field in the grid format using the grid() format
        self.email_field.grid(row = 0, column = 1, columnspan = 2, padx = 5, pady = 5)

        # creating a label using the Label() widget to display the error
        self.error_label = ttk.Label(self, foreground = 'red')
        # setting the position of the label in the grid format using the grid() method
        self.error_label.grid(row = 1, column = 1, sticky = tk.W, padx = 5, pady = 5)

        # creating a button using the Button() widget
        self.verify = ttk.Button(text = 'Verify')
        # setting the position of the button in the grid format using the grid() method
        self.verify.grid(row = 0, column = 4, padx = 5, pady = 5)

    # defining the method to display the message
    def displayMessage(self, error = '', color = 'black'):
        self.error_label['text'] = error
        self.email_field['foreground'] = color

    # defining the method to validate the entered email address
    def validate(self, value):
        """
        Validating the email address in the entry field
        :param value:
        :return:
        """
        pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
        if re.fullmatch(pattern, value) is None:
            return False

        self.displayMessage()
        return True

    # defining the method to display an error message if the entered data is invalid
    def on_invalid(self):
        """
        display the error message if the data is not valid
        :return:
        """
        self.displayMessage(error = 'Enter a valid email!', color = 'red')

# main function
if __name__ == '__main__':
    # instantiating the myApplication() class
    first_app = myApplication()
    # calling the mainloop() method to run the application
    first_app.mainloop()

Output 1: If the entered e-mail address is valid.

Validating Entry Widget in Python Tkinter

Output 2: If the entered e-mail address is not valid.

How does validation work in the above example?

Firstly, we have created a validate command with the help of the self.validate() method and %P substitution code.

Syntax:

Secondly, we have created the invalidcommand command that utilizes the self.on_invalid() method.

Syntax:

Next, we have configured the entry widget that utilizes the validate, validatecommand, and invalidcommand parameters.

Syntax:

self.email_field.config(validate = 'focusout', validatecommand = validate_cmd, invalidcommand = invalid_vcmd)

Moreover, we have defined the displayMessage() method that alters the text of the error_label widget and the text color of the email_field widget.

Syntax:

def displayMessage(self, error = '', color = 'black'):
self.error_label['text'] = error
self.email_field['foreground'] = color

After that, we have defined another method as validate() that performs validation of the value of the email_field widget.

Syntax:

    def validate(self, value):
        """
        Validating the email address in the entry field
        :param value:
        :return:
        """
        pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
        if re.fullmatch(pattern, value) is None:
            return False

        self.displayMessage()
        return True

The validate() method in the above snippet of code returns True if the input text is valid; otherwise, it returns False. If the entered text is a valid e-mail address, call the displayMessage() method to hide the error message and set the color of the text to black.

If the entered text turns out to be an invalid e-mail address, Tkinter will run the on_invalid() method.

At last, we have defined the on_invalid() method to display an error message and set the color of the text of the email_field widget to red.

Syntax:

    def on_invalid(self):
        """
        display the error message if the data is not valid
        :return:
        """
        self.displayMessage(error = 'Enter a valid email!', color = 'red')

The Conclusion

The Tkinter package utilizes the validate, validatecommand, and invalidcommand parameters on any input widget in order to validate the input data.
We have to pass a callable to the register() method in order to create a command for validatecommand and invalidacommand parameters.
The validatecommand parameter returns True for the valid data, whereas it returns False for the invalid one.
The invalidcommand parameter will be executed if the data is invalid or when the validatecommand parameter returns False.