Python desktop application development practice of the installation and use of PyQt

from  import QT_VERSION_STR, PYQT_VERSION_STR
QT_VERSION_STR, PYQT_VERSION_STR

import sys
from  import QApplication, QWidget, QLabel
from  import QIcon, QFont
from  import Qt
# Desktop application window class derived from QWidget class
class MyWindow(QWidget):  #QtWidgets module: contains application classes, window classes, control classes and component classes.
	# Constructor
    def __init__(self): 
        super().__init__() # Call the constructor of the base class
        ('Hello World') # Setting the title
        #(QIcon('res/')) # Can set the icon
        lab = QLabel('Hello World', self) # Instantiation tags
        (320,160) # Set label size
        (QFont('Arial', 32, )) # Set the font size
        () # Text centered within tags
        () # Display window
if __name__ == '__main__':
    app = QApplication() # Create an application that receives a list of parameters from the command line
    win = MyWindow() # Create the window, no QWidget entry is needed for initialization here.
    (()) # After the main loop of the application has finished，invocations()Methods to clean up the site

import sys
from  import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QHBoxLayout, QVBoxLayout
from  import QIcon
from  import Qt
class MyWindow(QWidget):
    def __init__(self):     
        super().__init__()
        ('Partition Layout')
        (400, 300, 320, 160) # Set window position and size
        lab_acc = QLabel('Account number:') # Instantiation tags
        account = QLineEdit() # Single line text edit box
        () # Text centered within tags
        lab_pw = QLabel('Password:')
        passwd = QLineEdit()
        ()
        () # Do not show password
        btn_ok = QPushButton('OK') #buttons
        btn_cancel = QPushButton('Cancel')
        # Use the Horizontal Layout Manager to layout the lab_acc control and the account control with 10 pixels of left and right white space.
        hbox_acc = QHBoxLayout() # Horizontal Layout Manager
        hbox_acc.addSpacing(10)  # Horizontal layout spacing
        hbox_acc.addWidget(lab_acc) #Put the instantiated tag account into the
        hbox_acc.addWidget(account) #Put #a single line text edit box into the
        hbox_acc.addSpacing(10)
        # Use the Horizontal Layout Manager to layout the lab_pw control and the passwd control with 10 pixels of left and right white space
        hbox_pw = QHBoxLayout() #Vertical Layout Manager
        hbox_pw.addSpacing(10)
        hbox_pw.addWidget(lab_pw)
        hbox_pw.addWidget(passwd)
        hbox_pw.addSpacing(10)
        # Layout the btn_ok control and btn_cancel control using the Horizontal Layout Manager
        hbox_btn = QHBoxLayout() # Horizontal Layout Manager
        hbox_btn.addStretch(5) # Set the left stretch factor
        hbox_btn.addWidget(btn_ok) # Add the btn_ok control
        hbox_btn.addWidget(btn_cancel) # Add the btn_cancel control
        hbox_btn.addStretch(1) # Set the right-hand stretch factor
        # Layout the top 3 horizontal layout managers using the vertical layout manager
        vbox = QVBoxLayout() 
        (10)
        (hbox_acc)
        (5)
        (hbox_pw)
        (1)
        (hbox_btn)
        (10)
        # Apply the Vertical Layout Manager to the window
        (vbox)
        () # Display window
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QPushButton, QGridLayout
from  import QIcon
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Raster Layout')
        () # Initialize the interface
        () # Display window
    def initUI(self):   #Create a 5*5 array, which will be put into the grid one by one later on
        keys = [
            ['(', ')', 'Back', 'Clear'],
            ['7',  '8',  '9',  '/'], 
            ['4',  '5',  '6',  '*'], 
            ['1',  '2',  '3',  '-'], 
            ['0',  '.',  '=',  '+']
        ]  
        grid = QGridLayout() # Create a grid layout manager
        (grid) # Apply the Grid Layout Manager to the window
        for i in range(5):
            for j in range(4):
                button = QPushButton(keys[i][j])
                (button, i, j) # Place elements into the grid, i is the horizontal coordinate, j is the vertical coordinate
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout, QFormLayout
from  import QIcon
from  import Qt
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Form Layout')
        (400, 300, 320, 200) # Set window position and size
        form = QFormLayout() # Create a form layout manager
        () # Set labels right-aligned (default left-aligned)
        name = QLineEdit() # Single line text edit box
        mobile = QLineEdit()
        passwd = QLineEdit()
        addr = QLineEdit()
        ('Name', name) #Put text into the form
        ('Mobile phone', mobile)
        ('Password', passwd)
        ('Correspondence address', addr)
        ("Please enter your name.") # Set placeholder gray body defaults
        ("Please enter a cell phone number.")
        ("Please enter the password.")
        ("Please enter a mailing address.")
        () #EchoMode is Normal: Display the entered characters. This is the default value
        () #EchoMode is NoEcho: show nothing. This may apply to passwords where even the length of the password should be kept secret.
        () #EchoMode as Password: Displays the platform-associated password mask characters instead of the actual characters typed.
        () #EchoMode is PasswordEchoOnEdit: show the entered characters when editing, otherwise show the same characters as the password.
        btn_ok = QPushButton('OK')
        vbox = QVBoxLayout() #Vertical Layout Manager Layout
        (10)
        (form)
        (1)
        (btn_ok, alignment=)
        (10)
        # Apply the Vertical Layout Manager to the window
        (vbox)
        () # Display window
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QLabel, QHBoxLayout
from  import Qt
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Events and event functions')
        (400, 300, 320, 80)
        () # Initialize the interface
        ()
    def initUI(self):
        lab = QLabel('Press Esc to close the window')
        box = QHBoxLayout()
        (1)
        (lab)
        (1)
        (box)
	# Override the event function of the "Keyboard press event" to specify the ESC key as the key that triggers the event (if not, all keys will trigger the event).
    def keyPressEvent(self, evt):
        if () == .Key_Escape.value: #There is a cross-reference table below the corresponding keyboard
            ()
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QLabel, QHBoxLayout
from  import Qt, QEvent
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Events and event functions')
        (400, 300, 320, 80)
        () # Initialize the interface
        ()
    def initUI(self):
        lab = QLabel('Press Esc to close the window')
        box = QHBoxLayout()
        (1)
        (lab)
        (1)
        (box)
	# Override the event function of the "Keyboard press event" to specify the ESC key as the key that triggers the event (if not, all keys will trigger the event).
    def keyPressEvent(self, evt):
        if () == .Key_Escape.value: 
            ()
    # Event Filtering Methods
    def eventFilter(self, objwatched, evt):
        if () == :
            print('Ignore key events')
            return True
        return super().eventFilter(objwatched, evt)
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (win) # Install event filters for this object
    (())

import sys
from  import QPushButton, QMessageBox, QApplication, QWidget
class Window(QWidget):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        ('Button Events')
        (300, 200)
         = QPushButton('Button', self)
        self.init_ui()
    def init_ui(self):
        (100, 30)
        (100, 50)   # Button Location
        (self.btn_hand) # Use connect to bind an event that is triggered when the button is clicked.
        ()
    def btn_hand(self):
        widget = QWidget()
        (widget, 'Pop messgae', 'OK') #Popup session box on triggered events
if __name__ == "__main__":
    app = QApplication()
    window = Window()
    ()
    (())

import sys
from  import pyqtSignal, Qt
from  import *
class WinForm(QWidget):
    # Custom signals without parameters
    button_clicked_signal = pyqtSignal()
    def __init__(self, parent=None):
        super().__init__(parent)
        ('Custom Signal and Slot Function Examples')
        (300, 150)
        # Receive signals to connect to custom slot functions
        self.button_clicked_signal.connect(self.pop_message)
    def pop_message(self):
        (self, 'Pop messgae', 'OK')
    def mousePressEvent(self, event):        # Rewrite the mouse press event
        super().mousePressEvent(event)
        if () == :     # When the left mouse button clicks
            self.button_clicked_signal.emit()     # Transmit signals
if __name__ == '__main__':
    app = QApplication()
    win = WinForm()
    ()
    (())

import sys
from  import QApplication,QMainWindow,QWidget,QProgressBar,QVBoxLayout,QPushButton
from  import QThread,QObject,pyqtSignal,Qt
#Thread Functions
class CountSever(QObject):
    _isrun = False Whether #threads run global variables
    countupdate = pyqtSignal()  #Customized signals
    # Constructor
    def __init__(self, interval) -> None:  #-> None Indicates that the type of value returned is unrestricted.
        super().__init__()
         = interval # Execution interval, initialized in the constructor specified, such as self.cs1 = CountSever(100) on behalf of every 100ms execution
    #Determine if a single thread is running
    def isrun(self,value:bool):
        self._isrun = value
    #Thread Run Functions
    def run(self):
        while True:
            pass
            while self._isrun:
                ()  #Fire custom signals when the thread is running
                () #Set the thread execution interval
 #ProgressBar main interface, QMainWindow - top-level window class, heavyweight control.
class MainWindow(QMainWindow):
    countstart = pyqtSignal(bool) # Customized signal objects
    def __init__(self) -> None: #-> None Indicates that the type of value returned is unrestricted.
        super().__init__() 
        self.init_ui()
        () # Call the following centering method
    def init_ui(self):
        ("Thread Refresh Progress Bar")
        (400, 300)
        self.main_widget = QWidget()
        (self.main_widget) #Center the display
        self.main_layout = QVBoxLayout()  ## Vertical Layout Manager Layout
        self.main_layout.setAlignment()
        self.main_widget.setLayout(self.main_layout)
        #Set up four progress bars
        self.progress_1 = QProgressBar(self) The #ProgressBar provides a horizontal or vertical progress bar with minimum and maximum steps specified using setMinimum() and setMaximum.
        self.progress_1.setRange(0,100)
        self.main_layout.addWidget(self.progress_1) # Add a progress bar control to the page layout
        self.progress_2 = QProgressBar(self)
        self.progress_2.setRange(0,100)
        self.main_layout.addWidget(self.progress_2)
        self.main_layout.addStretch(1)
        self.progress_3 = QProgressBar(self)
        self.progress_3.setRange(0, 100)
        self.main_layout.addWidget(self.progress_3)
        self.progress_4 = QProgressBar(self)
        self.progress_4.setRange(0, 100)
        self.main_layout.addWidget(self.progress_4)
        self.btn_start = QPushButton("Start")
        self.btn_start.setFixedSize(120,30)
        # Click the start button to trigger the start method defined below, the start method sends a True/Flase signal to the countstart custom object based on the current button, and then this True/Flase determines the result of isrun, which determines whether the thread runs or not
        self.btn_start.() 
        self.main_layout.addWidget(self.btn_start) #Putting the start button into the layout
        self.main_layout.setAlignment(self.btn_start,)
        # thread
        self.cs1 = CountSever(100) # Executed every 100ms
        # Customize the signal bound to the following event countupdate, the following self.progress_1.setValue(self.progress_1.value() + 1) means that the execution of a progress bar progress_1 value plus one, the range of values is 0-100, added to 100 will stop the thread
        self.() 
        (self.) # Custom signals are bound to the following events: determining whether a thread is running or not
        self.th1 = QThread()
        self.(self.th1) The #moveToThread function: assigns a thread to each of multiple tasks to execute.
        self.(self.) #QThread provides two signals, QThread::started() (fired when the thread starts) and QThread::finished() (fired when the thread has finished running)
        self.() #Threads start executing
        self.cs2 = CountSever(150)
        self.()
        (self.)
        self.th2 = QThread()
        self.(self.th2)
        self.(self.)
        self.()
        self.cs3 = CountSever(1000)
        self.()
        (self.)
        self.th3 = QThread()
        self.(self.th3)
        self.(self.)
        self.()
        self.cs4 = CountSever(1500)
        self.()
        (self.)
        self.th4 = QThread()
        self.(self.th4)
        self.(self.)
        self.()
    def setcenter(self): #Interface centered
        win_rect = ()
        screen_center = ().availableGeometry().center()
        win_rect.moveCenter(screen_center)
        (win_rect.topLeft())
    The #start method sends a True/Flase signal to the countstart custom object based on the current button, and then this True/Flase determines the result of isrun, which determines whether the thread runs or not
    def start(self):
        if self.btn_start.text() == "Start":
            (True)
            self.btn_start.setText("Pause")
        elif self.btn_start.text() == "Pause":
            (False)
            self.btn_start.setText("Start")
    def countupdate(self):
        if () == self.cs1:
            self.progress_1.setValue(self.progress_1.value() + 1)  # indicates that the execution of a progress bar progress_1 value plus one, the range of values is 0-100, add to 100 will stop the thread
        elif () == self.cs2:
            self.progress_2.setValue(self.progress_2.value() + 1)
        elif () == self.cs3:
            self.progress_3.setValue(self.progress_3.value() + 1)
        elif () == self.cs4:
            self.progress_4.setValue(self.progress_4.value() + 1)
if __name__ == "__main__":
    """ Main program run """
    app = QApplication()
    main_window = MainWindow()
    main_window.show()
    (())

import sys
from  import QApplication, QMainWindow, QWidget, QLabel, QHBoxLayout
from  import QIcon, QPixmap
from  import Qt
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        ('Status bar')
        () # Initialize the interface
        () # Window centered on the screen
        () # Display window
    def center(self):
        win_rect = () # Window rectangles (QRect class)
        scr_center = ().availableGeometry().center() # Screen Center
        win_rect.moveCenter(scr_center) # Center of window rectangle moved to center of screen
        (win_rect.topLeft()) # Moving window and window rectangle overlap
    def initUI(self):
        (400, 300)
        lab = QLabel()
        box = QHBoxLayout()
        (lab)
        self.main_widget = QWidget()
        self.main_widget.setLayout(box)
        (self.main_widget)
        # Enable mouse movement track sensing for widgets that need to handle mouse movement events.
        (True)
        self.main_widget.setMouseTracking(True)
        (True)
         = () # Return to the window status bar
        self.mouth_info = QLabel() # Label showing mouse coordinates
        (self.mouth_info) # Add tabs showing mouse coordinates to status bar
        (QLabel('All rights reserved ')) # Add a copyright notice to the status bar
        ('Ready to go', 3000) # Display message, disappears after 3 seconds
    def enterEvent(self, evt):
        """Responding to mouse-in-window events"""
        #(str, msecs=0): show str message lasts msecs milliseconds. If msecs is 0 (default), the message will be displayed until clearMessage() is called or showMessage is shown again to change the message.
        ('Mouse over', 3000) 
    def leaveEvent(self, evt):
        """Responds to mouse-out-of-window events."""
        ('Mouse over', 3000)
        self.mouth_info.setText('')
    def mouseMoveEvent(self, evt):
        """Responding to mouseover events"""
        pos = ()
        self.mouth_info.setText('x=%d, y=%d '%((), ()))
if __name__ == '__main__':
    app = QApplication() 
    win = MainWindow()
    (())

import sys
from  import QApplication, QMainWindow
from  import QIcon, QAction
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        ('Menu Bar')
        (250, 150)
        () # Initialize the interface
        () # Window centered on the screen
        () # Display window
    def center(self):
        win_rect = () # Window rectangles (QRect class)
        scr_center = ().availableGeometry().center() # Screen Center
        win_rect.moveCenter(scr_center) # Center of window rectangle moved to center of screen
        (win_rect.topLeft()) # Moving window and window rectangle overlap
    def initUI(self):
         = () # Return to the window status bar
        #openAction = QAction(QIcon('res/open_mso.png'), '& open', self) You can set the image in the first parameter
        openAction = QAction('& open', self)
        ('Ctrl+O')  #Setup shortcuts
        ('Open file') #Set status alert text
        (lambda : print('This pops up a dialog box to open the file'))
        saveAction = QAction('& Save', self)
        ('Ctrl+S')
        ('Save file')
        (lambda : print('This pops up a dialog box to save the file'))
        quitAction = QAction('& Exit', self)
        ('Ctrl+Q')
        ('Exit the program')
        ()
        singleAction = QAction('& Personal Privileges', self)
        ('Personal Privileges')
        (lambda : print('This responds to a personal permission action'))
        groupAction = QAction('& Group Permissions', self)
        ('Group Permissions')
        (lambda : print('Respond to group permission action here'))
        mb = ()
        fm = ('& Documentation')
        (openAction)
        (saveAction)
        ()
        subMenu = ('Permissions')
        (singleAction)
        (groupAction)
        ()
        (quitAction)
if __name__ == '__main__':
    app = QApplication() 
    win = MainWindow()
    (())

import sys
from  import QApplication, QMainWindow, QToolBar
from  import QIcon, QAction
from  import Qt
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        ('Toolbar')
        (400, 300)
        () # Initialize the interface
        () # Window centered on the screen
        () # Display window
    def center(self):
        win_rect = () # Window rectangles (QRect class)
        scr_center = ().availableGeometry().center() # Screen Center
        win_rect.moveCenter(scr_center) # Center of window rectangle moved to center of screen
        (win_rect.topLeft()) # Moving window and window rectangle overlap
    def initUI(self):
         = () # Return to the window status bar
        import sys
from  import QApplication, QMainWindow, QToolBar
from  import QIcon, QAction
from  import Qt
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        ('Toolbar')
        (400, 300)
        () # Initialize the interface
        () # Window centered on the screen
        () # Display window
    def center(self):
        win_rect = () # Window rectangles (QRect class)
        scr_center = ().availableGeometry().center() # Screen Center
        win_rect.moveCenter(scr_center) # Center of window rectangle moved to center of screen
        (win_rect.topLeft()) # Moving window and window rectangle overlap
    def initUI(self):
         = () # Return to the window status bar
        #openAction = QAction(QIcon('res/open_mso.png'), '& open', self) can add icon images
        openAction = QAction('& open', self)
        ('Ctrl+O')
        ('Open file')
        (lambda : print('This pops up a dialog box to open the file'))
        saveAction = QAction('& Save', self)
        ('Ctrl+S')
        ('Save file')
        (lambda : print('This pops up a dialog box to save the file'))
        quitAction = QAction('& Exit', self)
        ('Ctrl+Q')
        ('Exit the program')
        ()
        singleAction = QAction('& Personal Privileges', self)
        ('Personal Privileges')
        (lambda : print('This responds to a personal permission action'))
        groupAction = QAction('& Group Permissions', self)
        ('Group Permissions')
        (lambda : print('Respond to group permission action here'))
        mb = ()
        fm = ('& Documentation')
        (openAction)
        (saveAction)
        () #add a dividing line
        subMenu = ('Permissions')
        (singleAction)
        (groupAction)
        ()
        (quitAction)
        tb = ('Documentation')
        (openAction)
        (saveAction)
        tb = ('Exit')
        (quitAction)
        tb = QToolBar(self)
        ('Permissions')
        (, tb)
        (singleAction)
        (groupAction)
if __name__ == '__main__':
    app = QApplication() 
    win = MainWindow()
    (())
        openAction = QAction('& open', self)
        ('Ctrl+O')
        ('Open file')
        (lambda : print('This pops up a dialog box to open the file'))
        saveAction = QAction('& Save', self)
        ('Ctrl+S')
        ('Save file')
        (lambda : print('This pops up a dialog box to save the file'))
        quitAction = QAction('& Exit', self)
        ('Ctrl+Q')
        ('Exit the program')
        ()
        singleAction = QAction('& Personal Privileges', self)
        ('Personal Privileges')
        (lambda : print('This responds to a personal permission action'))
        groupAction = QAction('& Group Permissions', self)
        ('Group Permissions')
        (lambda : print('Respond to group permission action here'))
        mb = ()
        fm = ('& Documentation')
        (openAction)
        (saveAction)
        () #add a dividing line
        subMenu = ('Permissions')
        (singleAction)
        (groupAction)
        ()
        (quitAction)
        tb = ('Documentation')
        (openAction)
        (saveAction)
        tb = ('Exit')
        (quitAction)
        tb = QToolBar(self)
        ('Permissions')
        (, tb)
        (singleAction)
        (groupAction)
if __name__ == '__main__':
    app = QApplication() 
    win = MainWindow()
    (())

import sys, os
from  import QApplication, QMainWindow, QWidget, QPushButton, QGridLayout, QMessageBox, QInputDialog, QColorDialog, QFileDialog
from  import QIcon
from  import Qt
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        ('Dialog box')
        ()
        ()
    def initUI(self):
        grid = QGridLayout()
        btns = [
            ['Notification messages', 'Warning message', 'Error message', 'Confirmation message', 'About'],
            ['Color Selection', 'Save file', 'Open file', 'Select Path', 'Input']
        ]
        for i in (0, 1):
            for j in range(5):
                btn = QPushButton(btns[i][j])
                (self.on_button)
                (btn, i, j)
        self.main_widget = QWidget()
        self.main_widget.setLayout(grid)
        (self.main_widget)
         = ()
        ('Ready', 5000)
    def on_button(self):
        """Responding to keystrokes."""
        key = ().text()  #Calling this method in a slot function returns the emitter of the signal.
        (key, 1000)
        The #/warning/critical/question/about methods have different icons.
        #methodologiesAPI--int QMessageBox::information(QWidget *parent, const QString &title, const QString &text, button0|button1|button2)
        #parent is a pointer to the parent component, title is the title, text is the text text, and buttons 0, 1, and 2 are the three buttons, each separated by |.
        if key == 'Notification messages':
            reply = (self, 'Hints', ''The opponent admits defeat, the match is over.'', 
                           
            )
            (, 2000)
        elif key == 'Warning message':
            reply = (self, 'Warning', 'You can't mention peace continuously!', 
                
            )
            (, 2000)
        elif key == 'Error message':
            reply = (self, 'Error', 'Wrong move!', 
                |||
            )
            (, 2000)
        elif key == 'Confirmation message':
            reply = (self, 'Please select', 'To handheld and, accept?', 
                 |  | 
            )
            (, 2000)  # Display the result of the button selection to the message display bar in the bottom left corner
        elif key == 'About':
            (self, 'About', 'Genting Game S9 Spam Version')
        elif key == 'Color Selection':
            color = ()
            if ():
                ((), 2000)
        elif key == 'Save file':
            dase_dir = ()
            file_type = 'Python Files (*.py);;Text Files (*.txt);;All Files (*)'  #Select the file format you want to save: python or txt.
            fname, fext = (self, 'Save file', directory=dase_dir, filter=file_type)
            if fname:
                (fname, 2000)
        elif key == 'Open file':
            dase_dir = ()
            file_type = 'Python Files (*.py);;Text Files (*.txt);;All Files (*)'  #Select the file format you want to save: python or txt.
            fname = (self, 'Select file', directory=dase_dir, filter=file_type)
            if fname[0]:
                (fname[0], 2000)
        elif key == 'Select Path':
            dase_dir = ()
            folder = (self, 'Select folder', directory=dase_dir)
            (folder, 2000)
        elif key == 'Input':
            text, ok = (self, 'Input dialog', 'Please enter your room number:')
            if ok:                    
                (text, 2000)
if __name__ == '__main__':
    app = QApplication() 
    win = MainWindow()
    (())

import sys
from  import QApplication, QWidget, QLabel, QPushButton, QHBoxLayout, QVBoxLayout
from  import QIcon, QPixmap
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Albums')
        ()
        ()
        ()
    def center(self):
        """The window is centered on the screen."""
        win_rect = ()
        scr_center = ().availableGeometry().center()
        win_rect.moveCenter(scr_center)
        (win_rect.topLeft())
    def initUI(self):
         = 0
        #Note that here you have to select three images and put them in the res directory of the folder where the current pyhon script is located, where I put the previous screenshot.
         = ('D:/tools/python/srcipts2023/res/', 'D:/tools/python/srcipts2023/res/', 'D:/tools/python/srcipts2023/res/')
         = QLabel()
        (QPixmap([])) # Use label tags to display images, default from the first image in the list, followed by methods to switch images based on buttons
        btn_prev = QPushButton('<')
        btn_next = QPushButton('>')
        btn_prev.(self.on_btn)
        btn_next.(self.on_btn)
        #Set the border
        hbox = QHBoxLayout()
        (1)
        (btn_prev)
        (50)
        (btn_next)
        (1)
        vbox = QVBoxLayout()
        ()
        (hbox)
        (vbox)
    def on_btn(self):
        """Responding to keystrokes."""
        key = ().text()
        if key == '<':
            # When clicking the '<' button, take the last picture, generally by definition (-1) on the line, the role of the total number of residuals here is to be able to maintain the cycle, for example, the first one does not have a picture in front of it, it will jump to the last one
            #For example, at the first one = 0, (-1)%len() = -1%3 = 2, at this point jump to the last one
             = (-1)%len() 
        else:
             = (+1)%len()
        (QPixmap([]))  
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QLabel, QPushButton, QGridLayout, QVBoxLayout
from  import QIcon, QFont
from  import Qt
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Calculator')
        ()
        ()
        ()
    def center(self):
        """The window is centered on the screen."""
        win_rect = ()
        scr_center = ().availableGeometry().center()
        win_rect.moveCenter(scr_center)
        (win_rect.topLeft())
    def initUI(self):
        """Initialization Interface"""
        #lcd:Liquid Crystal Display (QLCDNumber)
         = QLabel('0')  #Default Display
        (QFont('Arial', 24, )) #Set the font
        () # Right-aligned
        ('background-color:#000030; color:#30ff30') #Set the color
        keys = [
            ['(', ')', 'Back', 'Clear'],
            ['7',  '8',  '9',  '/'], 
            ['4',  '5',  '6',  '*'], 
            ['1',  '2',  '3',  '-'], 
            ['0',  '.',  '=',  '+']
        ]
        grid = QGridLayout()
        box = QVBoxLayout()
        for i in range(5):
            for j in range(4):
                btn = QPushButton(keys[i][j])
                (self.on_btn)
                #Partition set color back, clear and op character color settings are different from others
                if i == 0 and j in (2, 3):
                    ('background-color:#f0e0d0')
                elif i > 0 and j == 3:
                    ('background-color:#a0f0e0')
                elif i == 4 and j == 2:
                    ('background-color:#f0e0a0')
                else:
                    ('background-color:#d9e4f1')
                (btn, i, j)
        ()
        (10) # Setting Interval
        (grid)
        (box)
    def on_btn(self):
        """Responding to keystrokes."""
        if () == 'Error':
            ('')
        key = ().text()
        if key == 'Clear':
            ('')
        elif key == 'Back':
            (()[:-1]) # Back to the previous step
        elif key == '=':
            try:
                result = str(eval(()))
            except:
                result = 'Error'
            (result)
        else:
            (() + key) # Splicing numbers directly to the end except for the calculation symbol and back/clear/=
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

import sys, time
from  import QApplication, QWidget, QLCDNumber, QPushButton, QVBoxLayout
from  import QIcon
from  import QObject, pyqtSignal, QThread
class ClockServer(QObject):
    """Time service"""
    update_time = pyqtSignal(str) # Update time signals
    isRun = False
    def run(self):
        """Initiate services."""
        while True:
            t0 = ()
            while :
                # Output the time difference when the signal is emitted (execute update_time method), because t0 is initialized only once, this time difference is the stopwatch timing, '%.2f'%+number means keep two decimal places.
                self.update_time.emit('%.2f'%(()-t0))  
                (0.01)    # Executed every 0.01s
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Stopwatch')
        (400, 300, 240, 140)
        ()
        ()
    def initUI(self):
         = QLCDNumber()  #QLCDNumber: Display LCD style numbers
        (6)  #Set the limiting digit to 6
        ('0:00') # Initial value
        #Setup button
         = QPushButton('Start')
        ('background-color:#f0d090')
        (self.on_btn)
        #Setup Styles
        vbox = QVBoxLayout()
        ()
        (5)
        ()
        (vbox)
         = ClockServer() # Create a timekeeping service, ts is a service object of your own name.
        .update_time.connect() # Connect update_time signal to LCD display function
         = QThread() # Create threads
        () # Add timekeeping services to the thread
        () # Set the startup method of the timing service to a threaded function
        () # Starting threads
    def on_btn(self):
        """Responding to keystrokes."""
        if () == 'Start':
             = True
            ('Stop')
        else:
             = False
            ('Start')
if __name__ == '__main__':
    app = QApplication()
    win = MyWindow()
    (())

import sys
from  import QApplication, QWidget, QVBoxLayout
from  import QAxWidget
class MyWindow(QWidget):
    def __init__(self):
        super().__init__()
        ('Embedded Browser')
        (960, 640)
        widget  = QAxWidget(self)  #The QAxWidget class is a QWidget that wraps an ActiveX control and can be used as a window class.
        # If setControl("E:/"); directly will load the word application to open the doc document.
        # Here {8856F961-340A-11D0-A96B-00C04FD705A2} is the UUID of the Microsoft Web Browser control, which stands for Open Browser.
        #UUID from registry HKEY_CLASSES_ROOT\.1\CLSID
        ("{EAB22AC3-30C1-11CF-A7EB-0000C05BAE0B}")
        ('Navigate(const QString&)', '') #"Navigate(const QString&)" is fixed, followed by the URL of the entry
        box = QVBoxLayout(self)
        (widget )
        ()
        ()
    def center(self):
        """The window is centered on the screen."""
        win_rect = ()
        scr_center = ().availableGeometry().center()
        win_rect.moveCenter(scr_center)
        (win_rect.topLeft())
if __name__ == '__main__':
    app = QApplication() 
    win = MyWindow()
    (())

pip install pyqt6-tools
pip install pyside6

import sys
from PyQt6 import QtWidgets, uic
app = ()
window = ("D:/tools/python/srcipts2023/")
()
()

import sys 
from PyQt6 import QtWidgets, uic
from test0628 import Ui_MainWindow
class MyUi(, Ui_MainWindow):
    def __init__(self, *args, obj=None, **kwargs):
        super(MyUi, self).__init__(*args, **kwargs)
        (self)
app = ()
window = MyUi()
()
()