In this chapter, we will learn to use the following widgets:

• Displaying a welcome message
• Using the Radio Button widget
• Grouping radio buttons
• Displaying options in the form of checkboxes
• Displaying two groups of checkboxes

We will be learning to create GUI applications using the Qt toolkit. The Qt toolkit, known simply as Qt, is a cross-platform application and UI framework developed byTrolltech, which is used for developing GUI applications. It runs on several platforms, including Windows, macOS X, Linux, and other UNIX platforms. It is also referred to as a widget toolkit because it provides widgets such as buttons, labels, textboxes, push buttons, and list boxes, which are required for designing a GUI. It includes a cross-platform collection of classes, integrated development tools, and a cross-platform IDE. To create real-time applications, we will be making use of Python bindings for the Qt toolkit called, PyQt5.

PyQt is a set of Python bindings for the cross-platform application framework that combines all the advantages of Qt and Python. With PyQt, you can include Qt libraries in Python code, enabling you to write GUI applications in Python. In other words, PyQt allows you to access all the facilities provided by Qt through Python code. Since PyQt depends on the Qt libraries to run, when you install PyQt, the required version of Qt is also installed automatically on your machine.

A GUI application may consist of a main window with several dialogs or just a single dialog. A small GUI application usually consists of at least one dialog. A dialog application contains buttons. It doesn't contain a menu bar, toolbar, status bar, or central widget, whereas a main window application normally has all of those.

Dialogs are of the following two types:

• Modal: This dialog is one that blocks the user from interacting with other parts of the application. The dialog is the only part of the application that the user can interact with. Until the dialog is closed, no other part of the application can be accessed.
• Modeless: This dialog is the opposite of a modal dialog. When a modeless dialog is active, the user is free to interact with the dialog and with the rest of the application.

There are the following two ways to write a GUI application:

• From scratch, using a simple text editor
• With Qt Designer, a visual design tool with which you can create a user interface quickly using drag and drop

You will be using Qt Designer to develop GUI applications in PyQt, as it is a quick and easy way to design user interfaces without writing a single line of code. So, launch Qt Designer by double-clicking on its icon on desktop.

On opening, Qt Designer asks you to select a template for your new application, as shown in the following screenshot:

Qt Designer provides a number of templates that are suitable for different kinds of applications. You can choose any of these templates and then click theCreate button.

Qt Designer provides the following predefined templates for a new application:

• Dialog with Buttons Bottom: This template creates a form with theOK andCancel buttons in the bottom-right corner.
• Dialog with Buttons Right: This template creates a form with theOK andCancel buttons in the top-right corner.
• Dialog without Buttons: This template creates an empty form on which you can place widgets. The superclass for dialogs isQDialog.
• Main Window: This template provides a main application window with a menu bar and a toolbar that can be removed if not required.
• Widget: This template creates a form whose superclass isQWidget rather thanQDialog.

Every GUI application has a top-level widget and the rest of the widgets are called its children. The top-level widget can beQDialog,QWidget, orQMainWindow, depending on the template you require. If you want to create an application based on the dialog template, then the top-level widget or the first class that you inherit will be QDialog. Similarly, to create an application based on theMain Window template, the top-level widget will beQMainWindow, and to create the application based on theWidget template, you need to inherit theQWidget class. As mentioned previously, the rest of the widgets that are used for the user interface are called child widgets of the classes.

Qt Designer displays a menu bar and toolbar at the top. It shows aWidget box on the left that contains a variety of widgets used to develop applications, grouped in sections. All you have to do is drag and drop the widgets you want from the form. You can arrange widgets in layouts, set their appearance, provide initial attributes, and connect their signals to slots.

In this recipe, the user will be prompted to enter his/her name followed by clicking a push button. On clicking the button, a welcome message will appear, "Hello," followed by the name entered by the user. For this recipe, we need to make use of three widgets,Label,Line Edit, andPush Button. Let's understand these widgets one by one.

TheLabel widget isan instance of theQLabelclass and is used for displaying messages and images. Because theLabel widgets simply display results of computations and don't take any input, they are simply used for supplying information on the screen. 

The following are the methods provided by theQLabel class:

• setText(): This method assigns text to theLabel widget
• setPixmap(): This method assignspixmap, an instance of theQPixmap class, to theLabel widget
• setNum():This method assigns an integer or double value to theLabel widget
• clear():This method clears text from theLabel widget

The default text ofQLabel isTextLabel. That is, when you add aQLabel class to a form by dragging aLabel widget and dropping it on the form, it will displayTextLabel. Besides usingsetText(), you can also assign text to a selectedQLabel object by setting itstext property in theProperty Editor window.

TheLine Edit widget is that is popularly used for entering single-line data. TheLine Edit widget is an instance of theQLineEdit class, and you can not only enter, but also edit the data too. Besides entering data, you can undo, redo, cut, and paste data in theLine Edit widget. 

The following are the methods provided by theQLineEdit class:

• setEchoMode(): It sets the echo mode of theLine Edit widget. That is, it determines how the contents of theLine Edit widget are to be displayed. The available options are as follows:
• Normal: This is the default mode and it displays characters the way they are entered
• NoEcho: It switches off theLine Edit echo, that is, it doesn't display anything
• Password: This option is used for password fields, no text will be displayed; instead, asterisks appear for the text entered by the user
• PasswordEchoOnEdit: It displays the actual text while editing the password fields, otherwise it will display the asterisks for the text
• maxLength(): This method is used to specify the maximum length of text that can be entered in theLine Edit widget. 
• setText(): This method is used for assigning text to theLine Edit widget.
• text(): This method accesses the text entered in theLine Edit widget.
• clear(): This method clears or deletes the complete content of theLine Edit widget.
• setReadOnly(): When the Boolean value true is passed to this method, it will make theLine Edit widget read-only, that is, non-editable. The user cannot make any changes to the contents displayed through theLine Edit widget, but can only copy. 
• isReadOnly(): This method returns the Boolean value true if theLine Edit widget is in read-only mode, otherwise it returns false.
• setEnabled(): By default, theLine Edit widget is enabled, that is, the user can make changes to it. But if the Boolean value false is passed to this method, it will disable theLine Edit widget so the user cannot edit its content, but can only assign text via thesetText() method.
• setFocus(): This method positions the cursor on the specifiedLine Edit widget.

To display a push button in an application, you need to create an instance of theQPushButton class. When assigning text to buttons, you can create shortcut keys by preceding any character in the text with an ampersand. For example, if the text assigned to a push button is Click Me, the characterC will be underlined to indicate that it is a shortcut key, and the user can select the button by pressingAlt +C. The button emits theclicked() signal if it is activated. Besides text, an icon can also be displayed in the push button. The methods for displaying text and an icon in a push button are as follows:

• setText(): This method is used to assign text to the push button
• setIcon(): This method is used to assign an icon to the push button

Let's create a new application based on theDialog without Buttons template. As said earlier, this application will prompt the user to enter a name and, on clicking the push button after entering a name, the application with display a hello message along with the entered name. Here are the steps to create this application:

1. Drag aLabel widget from theDisplay Widgets category and drop it on the form. Set its text property toEnter your name. Set theobjectNameproperty of theLabelwidget tolabelResponse.
2. Drag one more Labelwidget from theDisplay Widgetscategory and drop it on the form. Do not change thetext property of this Label widget and leave itstext property to its default value,TextLabel. This is because thetextproperty of thisLabelwidget will be set through code, that is, it will be used to display the hello message to the user.
3. Drag oneLine Edit from theInput Widgets category and drop it on the form.Set its objectNamepropertytolineEditName.
4. Drag onePush Button widget from theButtons category and drop it onto the form. Set its text property toClick. You can change thetext property of thePush Button widget through any of three ways: by double-clicking thePush Button widget and overwriting the default text, by right-clicking thePush Button widget and selecting theChange text... option from the context menu that pops up, or by selecting thetext property from theProperty Editor window and overwriting the default text.
5. Set the objectName property of thePush Button widget toButtonClickMe.

6. Save the application with the namedemoLineEdit.ui. Now the form will appear, as shown in the following screenshot:

The user interface that you create with Qt Designer is stored in a.ui file that includes all the form's information: its widgets, layout, and so on. The.ui file is an XML file, and you need to convert it to Python code. That way, you can maintain a clear separation between the visual interface and the behavior implemented in code.

7. To use the.ui file, you first need to convert it into a Python script. The command utility that you will use for converting a.ui file into a Python script ispyuic5. In Windows, thepyuic5 utility is bundled with PyQt. To do the conversion, you need to open a Command Prompt window and navigate to the folder where the file is saved and issue the following command:

C:\Pythonbook\PyQt5>pyuic5 demoLineEdit.ui -o demoLineEdit.py

Let's assume that we saved the form at this location: C:\Pythonbook\PyQt5>. The preceding command shows the conversion of thedemoLineEdit.ui file into a Python script,demoLineEdit.py.

The code of the generated Python script file, demoLineEdit.py, can be seen in the source code bundle of this book.

8. Treat the code in the demoLineEdit.py file as a header file, and import it to the file from which you will invoke its user interface design.

9. Let's create another Python file with the name callLineEdit.py and import the demoLineEdit.py code into it as follows:

import sys
from PyQt5.QtWidgets import QDialog, QApplication
from demoLineEdit import *
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.ButtonClickMe.clicked.connect(self.dispmessage)
        self.show()
    def dispmessage(self):
        self.ui.labelResponse.setText("Hello "
        +self.ui.lineEditName.text())
if __name__=="__main__":
    app = QApplication(sys.argv)
    w = MyForm()
    w.show()
    sys.exit(app.exec_())

ThedemoLineEdit.py file is very easy to understand. A class with the name of the top-level object is created, withUi_ prepended. Since the top-level object used in our application isDialog, theUi_Dialog class is created and stores the interface elements of our widget. That class has two methods,setupUi() andretranslateUi(). ThesetupUi() method sets up the widgets; it creates the widgets that you use while defining the user interface in Qt Designer. The method creates the widgets one by one and also sets their properties. ThesetupUi() method takes a single argument, which is the top-level widget in which the user interface (child widgets) is created. In our application, it is an instance ofQDialog. TheretranslateUi() method translates the interface.

Let's understand what callLineEdit.py does statement-wise:

1. It imports the necessary modules.QWidget is the base class of all user interface objects in PyQt5.
2. It creates a newMyForm class that inherits from the base class,QDialog.
3. It provides the default constructor forQDialog. The default constructor has no parent, and a widget with no parent is known as a window.
4. Event handling in PyQt5 uses signals and slots. A signal is an event, and a slot is a method that is executed on the occurrence of a signal. For example, when you click a push button, a clicked() event, also known as a signal, occurs. Theconnect() method connects signals with slots. In this case, the slot is a method:dispmessage(). That is, when the user clicks the push button, thedispmessage() method will be invoked.clicked() is an event here and an event handling loop waits for an event to occur and then dispatches it to perform some task. The event handling loop continues to work until either theexit() method is called or the main widget is destroyed.
5. It creates an application object with the nameapp through theQApplication() method. Every PyQt5 application must create sys.argv application object which contains a list of arguments from the command line, and it is passed to the method while creating the application object. The sys.argv parameter helps in passing and controlling the startup attributes of a script.

6. An instance of theMyForm class is created with the namew.
7. Theshow() method will display the widget on the screen.
8. Thedispmessage() method performs event handling for the push button. It displays the Hello text, along with the name entered in theLine Edit widget.
9. Thesys.exit() method ensures a clean exit, releasing memory resources.

On executing the preceding program, you get a window with theLine Edit andPush Button widgets, as shown in the following screenshot. When the push button is selected, thedisplmessage() method will be executed, displaying theHello message along with the user's name that is entered in theLine Edit widget:

This recipe displays certain flight types viaRadio Button and when the user selects the radio button, the price associated with that flight will be displayed. We need to first understand the workings ofRadio Button. 

TheRadio Button widgets are very popular when you want the user to select only one option out of the available options. Such options are known as mutually exclusive options. When the user selects an option, the previously selected option is automatically deselected. TheRadio Button widgets are instances of theQRadioButton class. Every radio button has an associated text label. The radio button can be either in selected (checked) or unselected (unchecked) states. If you want two or more sets of radio buttons, where each set allows the exclusive selection of a radio button, put them into different button groups (instances ofQButtonGroup). The methods provided byQRadioButton are shown next.

TheQRadioButton class provides the following methods:

• isChecked(): This method returns the Boolean value true if the button is in the selected state.
• setIcon(): This method displays an icon with the radio button.
• setText(): This method assigns the text to the radio button. If you want to specify a shortcut key for the radio button, precede the preferred character in the text with an ampersand (&). The shortcut character will be underlined.
• setChecked(): To make any radio button appear selected by default, pass the Boolean value true to this method.

Signals emitted by QRadioButton are as follows:

• toggled(): This signal is emitted whenever the button changes its state from checked to unchecked or vice versa
• clicked(): This signal is emitted when a button is activated (that is, pressed and released) or when its shortcut key is pressed
• stateChanged(): This signal is emitted when a radio button changes its state from checked to unchecked or vice versa

To understand the concept of radio buttons, let's create an application that asks the user to select the flight type and displays three options, First Class,Business Class, andEconomy Class, in the form of radio buttons. On selecting an option through the radio button, the price for that flight will be displayed.

Let's create a new application based on theDialog without Buttons template. This application will display different flight types along with their respective prices. When a user selects a flight type, its price will be displayed on the screen:

1. Drag and drop twoLabel widgets and threeRadio Button widgets onto the form.
2. Set thetext property of the firstLabel widget toChoose the flight type and delete thetext property of the secondLabel widget. Thetext property of the secondLabel widget will be set through code; it will be used to display the price of the selected flight type.
3. Set thetext property of the threeRadio Button widgets toFirst Class $150,Business Class $125, andEconomy Class $100.
4. Set theobjectName property of the secondLabel widget tolabelFare. The default object names of the three radio buttons areradioButton,radioButton_2, andradioButton_3. Change theobjectName property of these three radio buttons toradioButtonFirstClass,radioButtonBusinessClass, andradioButtonEconomyClass.
5. Save the application with namedemoRadioButton1.ui.

Take a look at the following screenshot: 

ThedemoRadioButton1.ui application is an XML file and needs to be converted into Python code through thepyuic5command utility. The generated Python code,demoRadioButton1.py, can be seen in the source code bundle of this book.

6. Import thedemoRadioButton1.py file as a header file in the Python script that you are going to create next to invoke the user interface design.
7. In the Python script, write the code to display the flight type on the basis of the radio button selected by the user. Name the source filecallRadioButton1.py; its code is shown here:

import sys
from PyQt5.QtWidgets import QDialog, QApplication
from demoRadioButton1 import *
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.radioButtonFirstClass.toggled.connect(self.
        dispFare)
        self.ui.radioButtonBusinessClass.toggled.connect(self.
        dispFare)
        self.ui.radioButtonEconomyClass.toggled.connect(self.
        dispFare)
        self.show()
    def dispFare(self):
        fare=0
        if self.ui.radioButtonFirstClass.isChecked()==True:
            fare=150
        if self.ui.radioButtonBusinessClass.isChecked()==True:
            fare=125
        if self.ui.radioButtonEconomyClass.isChecked()==True:
            fare=100
        self.ui.labelFare.setText("Air Fare is "+str(fare))
if __name__=="__main__":
    app = QApplication(sys.argv)
    w = MyForm()
    w.show()
    sys.exit(app.exec_())

Thetoggled() event ofRadio Button is connected to thedispFare() function, which will display the price of the selected flight type. In thedispFare() function, you check the state of the radio buttons. Hence, ifradioButtonFirstClass is selected, the value50 is assigned to the fare variable. Similarly, ifradioButtonBusinessClass is selected, the value125 is assigned to thefare variable. Similarly, the value100 is assigned to thefare variable whenradioButtonEconomyClass is selected. Finally, the value in thefare variable is displayed vialabelFare.

On executing the previous program, you get a dialog that displays three flight types and prompts the user to select the one that he/she wants to use for travel. On selecting a flight type, the price of the selected flight type is displayed, as shown in the following screenshot:

In this application, we will learn to create two groups of radio buttons. The user can select radio buttons from either group and accordingly the result or text will appear on the screen.

We will display a dialog that displays shirts of different sizes and different payment methods. On selecting a shirt size and a payment method, the selected shirt size and payment method will be displayed on the screen. We will create two groups of radio buttons, one of the shirt sizes and other payment methods. The shirt size group displays four radio buttons showing four different types of the size such as M,L,XL, andXXL, whereM stands for medium size,L stands for large size, and so on. The payment method group displays three radio buttons, Debit/Credit Card,NetBanking, andCash On Delivery. The user can select any radio button from either of the groups. When the user selects any of the shirt sizes or payment methods, the selected shirt size and payment method will be displayed.

Let's recreate the preceding application step by step:

1. Create a new application based on theDialog without Buttons template.
2. Drag and drop threeLabel widgets and sevenRadio Button widgets. Out of these seven radio buttons, we will arrange four radio buttons in one vertical layout and the other three radio buttons in the second vertical layout. The two layouts will help in grouping these radio buttons. Radio buttons being mutually exclusive will allow only one radio button to be selected from a layout or group.
3. Set thetext property of the first twoLabel widgets toChoose your Shirt Size andChoose your payment method respectively.
4. Delete thetext property of the thirdLabel widget because we will display the selected shirt size and payment method through the code.
5. In the Property Editor window, increase the font size of all the widgets to increase their visibility in the application.
6. Set thetext property of the first four radio buttons to M, L, XL, andXXL. Arrange these four radio buttons into one vertical layout.
7. Set thetext property of the next three radio buttons toDebit/Credit Card,NetBanking, andCash On Delivery. Arrange these three radio buttons into a second vertical layout. Remember, these vertical layouts help by grouping these radio buttons.
8. Change the object names of the first four radio buttons toradioButtonMedium,radioButtonLarge,radioButtonXL, andradioButtonXXL.

9. Set theobjectName property of the firstVBoxLayout layout toverticalLayout. TheVBoxLayout layout will be used for aligning radio buttons vertically.
10. Change the object names of next three radio buttons toradioButtonDebitCard,radioButtonNetBanking, andradioButtonCashOnDelivery.
11. Set the objectName property of the secondQVBoxLayout object toverticalLayout_2.
12. Set the objectName property of the thirdLabel widget tolabelSelected. It is through thisLabel widget that the selected shirt size and payment method will be displayed.
13. Save the application with the namedemoRadioButton2.ui.
14. Now, the form will appear, as shown in the following screenshot:

The.ui (XML) file is then converted into Python code through thepyuic5 command utility. You can find the Python code,demoRadioButton2.py, in the source code bundle for this book.

15. Import thedemoRadioButton2.py file, as a header file in our program to invoke the user interface design and to write code to display the selected shirt size and payment method through aLabel widget when the user selects or unselects any of the radio buttons.

16. Let's name the programcallRadioButton2.pyw; its code is shown here:

import sys
from PyQt5.QtWidgets import QDialog, QApplication
from demoRadioButton2 import *
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.radioButtonMedium.toggled.connect(self.
        dispSelected)
        self.ui.radioButtonLarge.toggled.connect(self.
        dispSelected)
        self.ui.radioButtonXL.toggled.connect(self.dispSelected)
        self.ui.radioButtonXXL.toggled.connect(self.
        dispSelected)
        self.ui.radioButtonDebitCard.toggled.connect(self.
        dispSelected)
        self.ui.radioButtonNetBanking.toggled.connect(self.
        dispSelected)
        self.ui.radioButtonCashOnDelivery.toggled.connect(self.
        dispSelected)
        self.show()
    def dispSelected(self):
        selected1="";
        selected2=""
        if self.ui.radioButtonMedium.isChecked()==True:
            selected1="Medium"
        if self.ui.radioButtonLarge.isChecked()==True:
            selected1="Large"
        if self.ui.radioButtonXL.isChecked()==True:
            selected1="Extra Large"
        if self.ui.radioButtonXXL.isChecked()==True:
            selected1="Extra Extra Large"
        if self.ui.radioButtonDebitCard.isChecked()==True:
            selected2="Debit/Credit Card"
        if self.ui.radioButtonNetBanking.isChecked()==True:
            selected2="NetBanking"
        if self.ui.radioButtonCashOnDelivery.isChecked()==True:
            selected2="Cash On Delivery"
        self.ui.labelSelected.setText("Chosen shirt size is
        "+selected1+" and payment method as " + selected2)
if __name__=="__main__":
    app = QApplication(sys.argv)
    w = MyForm()
    w.show()
    sys.exit(app.exec_())

Thetoggled() event of all the radio buttons is connected to thedispSelected() function, which will display the selected shirt size and payment method. In thedispSelected() function, you check the status of the radio buttons to find out whether they are checked or unchecked. On the basis of the selected radio button in the first vertical layout, the value of theselected1 variable will be set toMedium,Large,Extra Large, orExtra Extra Large. Similarly, from the second vertical layout, depending on the radio button selected, the value of theselected2variable will be initialized toDebit/Credit Card,NetBanking, orCash On Delivery. Finally, the shirt size and payment method assigned to theselected1variable and selected variables will be displayed via the labelSelectedwidget. On running the application, you get a dialog prompting you to select the shirt size and payment method. On selecting a shirt size and payment method, the selected shirt size and payment method are displayed via the Labelwidget, as shown in the following screenshot:

While creating applications, you may come across a situation where you need to provide several options for the user to select from. That is, you want the user to select one or more than one option from a set of options. In such situations, you need to make use of checkboxes. Let's find out more about checkboxes.

Whereas radio buttons allow only one option to be selected in a group, checkboxes allow you to select more than one option. That is, selecting a checkbox will not affect other checkboxes in the application. Checkboxes are displayed with a text label as an instance of theQCheckBox class. A checkbox can be in any of three states: selected (checked), unselected (unchecked), or tristate (unchanged). Tristate is a no change state; the user has neither checked nor unchecked the checkbox. 

The following are the methods provided by the QCheckBox class:

• isChecked(): This method returns the Boolean value true if the checkbox is checked, and otherwise returns false.
• setTristate(): If you don't want the user to change the state of the checkbox, you pass the Boolean value true to this method. The user will not be able to check or uncheck the checkbox.
• setIcon(): This method is used to display an icon with the checkbox.
• setText(): This method assigns text to the checkbox. To specify a shortcut key for the checkbox, precede the preferred character in the text with an ampersand. The shortcut character will appear as underlined.
• setChecked(): In order to make a checkbox appear as checked by default, pass the Boolean value true to this method.

The signals emitted by QCheckBox are as follows:

• clicked(): This signal is emitted when a checkbox is activated (that is, pressed and released) or when its shortcut key is pressed
• stateChanged(): This signal is emitted whenever a checkbox changes its state from checked to unchecked or vice versa

To understand theCheck Box widget, let's assume that you run a restaurant where several food items, such as pizzas, are sold. The pizza is sold along with different toppings, such as extra cheese, extra olives, and so on, and the price of each topping is also mentioned with it. The user can select a regular pizza with one or more toppings. What you want is that when a topping is selected, the total price of the pizza, including the selected topping, is displayed.

The focus of this recipe is to understand how an action is initiated when the state of a checkbox changes from checked to unchecked or vice versa. Following is the step-by-step procedure to create such an application:

1. Begin by creating a new application based on theDialog without Buttons template.
2. Drag and drop threeLabel widgets and threeCheck Box widgets onto the form.
3. Set thetext property of the first twoLabel widgets toRegular Pizza $10 andSelect your extra toppings.
4. In theProperty Editor window, increase the font size of all three labels and checkboxes to increase their visibility in the application.
5. Set thetext property of the three checkboxes toExtra Cheese $1,Extra Olives $1, andExtra Sausages $2. The default object names of the three checkboxes arecheckBox,checkBox_2, andcheckBox_3.
6. Change these tocheckBoxCheese,checkBoxOlives, andcheckBoxSausages, respectively.
7. Set theobjectName property of theLabel widget tolabelAmount.

8. Save the application with the namedemoCheckBox1.ui. Now, the form will appear as shown in the following screenshot:

The.ui (XML) file is then converted into Python code through thepyuic5 command utility. The Python code generated in thedemoCheckBox1.pyfile can be seen in the source code bundle of this book.

9. Import thedemoCheckBox1.py file, as a header file in our program to invoke the user interface design and to write code to calculate the total cost of regular pizza, along with the selected toppings, through aLabel widget when the user selects or unselects any of the checkboxes.
10. Let's name the programcallCheckBox1.pyw; its code is shown here:

import sys
from PyQt5.QtWidgets import QDialog
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton
from demoCheckBox1 import *
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.checkBoxCheese.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxOlives.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxSausages.stateChanged.connect(self.
        dispAmount)
        self.show()
    def dispAmount(self):
        amount=10
        if self.ui.checkBoxCheese.isChecked()==True:
            amount=amount+1
        if self.ui.checkBoxOlives.isChecked()==True:
            amount=amount+1
        if self.ui.checkBoxSausages.isChecked()==True:
            amount=amount+2
        self.ui.labelAmount.setText("Total amount for pizza is
        "+str(amount))
if __name__=="__main__":
    app = QApplication(sys.argv)
    w = MyForm()
    w.show()
    sys.exit(app.exec_())

ThestateChanged() event of checkboxes is connected to thedispAmount function, which will calculate the cost of the pizza along with the toppings selected. In thedispAmount function, you check the status of the checkboxes to find out whether they are checked or unchecked. The cost of the toppings whose checkboxes are checked is added and stored in theamount variable. Finally, the addition of the amount stored in theamount variable is displayed vialabelAmount. On running the application, you get a dialog prompting you to select the toppings that you want to add to your regular pizza. On selecting any toppings, the amount of the regular pizza along with the selected toppings will be displayed on the screen, as shown in the following screenshot:

In this application, we will learn to make two groups of checkboxes. The user can select any number of checkboxes from either group and, accordingly, the result will appear.

We will try displaying a menu of a restaurant where different types of ice creams and drinks are served. We will create two groups of checkboxes, one of ice creams and the other of drinks. The ice cream group displays four checkboxes showing four different types of ice cream, mint chocolate chip, cookie dough, and so on, along with their prices. The drinks group displays three checkboxes, coffee, soda, and so on, along with their prices. The user can select any number of checkboxes from either of the groups. When the user selects any of the ice creams or drinks, the total price of the selected ice creams and drinks will be displayed.

Here are the steps to create an application, which explain how checkboxes can be arranged into different groups and how to take respective action when the state of any checkbox from any group changes:

1. Create a new application based on theDialog without Buttons template.
2. Drag and drop fourLabel widgets, sevenCheck Box widgets, and twoGroup Box widgets onto the form.
3. Set thetext property of the first three Label widgets toMenu,Select your IceCream, andSelect your drink respectively.
4. Delete thetext property of the fourthLabel widget because we will display the total amount of the selected ice creams and drinks through the code.
5. ThroughProperty Editor, increase the font size of the all the widgets to increase their visibility in the application.
6. Set thetext property of the first four checkboxes toMint Choclate Chips $4,Cookie Dough $2,Choclate Almond $3, andRocky Road $5. Put these four checkboxes into the first group box.
7. Set thetext property of the next three checkboxes toCoffee $2,Soda $3, andTea $1 respectively. Put these three checkboxes into the second group box.

8. Change the object names of the first four checkboxes tocheckBoxChoclateChips,checkBoxCookieDough,checkBoxChoclateAlmond, andcheckBoxRockyRoad.
9. Set theobjectName property of the first group box togroupBoxIceCreams.
10. Change theobjectName property of the next three checkboxes tocheckBoxCoffee,checkBoxSoda, andcheckBoxTea.
11. Set theobjectName property of the second group box togroupBoxDrinks.
12. Set theobjectName property of the fourthLabel widget tolabelAmount.
13. Save the application with the namedemoCheckBox2.ui. It is through thisLabel widget that the total amount of the selected ice creams and drinks will be displayed, as shown in the following screenshot:

The.ui (XML) file is then converted into Python code through thepyuic5 command utility. You can find the generated Python code, the demoCheckbox2.py file, in the source code bundle of this book.

14. Import thedemoCheckBox2.py file as a header file in our program to invoke the user interface design, and to write code to calculate the total cost of ice creams and drinks through aLabel widget when the user selects or unselects any of the checkboxes.
15. Let's name the programcallCheckBox2.pyw; its code is shown here:

import sys
from PyQt5.QtWidgets import QDialog
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton
from demoCheckBox2 import *
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.checkBoxChoclateAlmond.stateChanged.connect
        (self.dispAmount)
        self.ui.checkBoxChoclateChips.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxCookieDough.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxRockyRoad.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxCoffee.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxSoda.stateChanged.connect(self.
        dispAmount)
        self.ui.checkBoxTea.stateChanged.connect(self.
        dispAmount)
        self.show()
    def dispAmount(self):
        amount=0
        if self.ui.checkBoxChoclateAlmond.isChecked()==True:
            amount=amount+3
        if self.ui.checkBoxChoclateChips.isChecked()==True:
            amount=amount+4
        if self.ui.checkBoxCookieDough.isChecked()==True:
            amount=amount+2
        if self.ui.checkBoxRockyRoad.isChecked()==True:
            amount=amount+5
        if self.ui.checkBoxCoffee.isChecked()==True:
            amount=amount+2
        if self.ui.checkBoxSoda.isChecked()==True:
            amount=amount+3
        if self.ui.checkBoxTea.isChecked()==True:
            amount=amount+1
        self.ui.labelAmount.setText("Total amount is
        $"+str(amount))
if __name__=="__main__":
    app = QApplication(sys.argv)
    w = MyForm()
    w.show()
    sys.exit(app.exec_())

ThestateChanged() event of all the checkboxes is connected to thedispAmount function, which will calculate the cost of the selected ice creams and drinks. In thedispAmount function, you check the status of the checkboxes to find out whether they are checked or unchecked. The cost of the ice creams and drinks whose checkboxes are checked is added and stored in theamount variable. Finally, the addition of the amount stored in theamount variable is displayed via the labelAmount widget. On running the application, you get a dialog prompting you to select the ice creams or drinks that you want to order. On selecting the ice creams or drinks, the total amount of the chosen items will be displayed, as shown in the following screenshot: