【GUI编程】PyQt5环境搭载与基本功能使用

中文教程
官方教程

环境搭载

---

一、安装pyQT5模块包

方法一：到Pycharm工程解析器（project interpreter）中搜索PyQt5并添加到工程中；
方法二：管理员下运行cmd - 输入pip install pyQt5；
方法三：到PyQt5下载页面下载对应whl文件，管理员下运行cmd - cd + whl所在目录 - pip install + whl全名；

二、安装PyQt5-tools模块包

方法一：管理员下运行cmd - 输入pip install pyQt5-tools；
方法二：到pyqt5-tools下载页面下载对应python版本和电脑版本的whl文件，管理员下运行cmd - cd + whl所在目录 - pip install + whl全名；

如：python3.7 和 64位系统选择：pyqt5_tools-5.13.0.1.5-cp37-none-win_amd64.whl

三、配置QtDesigner和pyUIC

QtDesigner 可实现可视化构造UI界面，一般安装PyQt5后，系统会默认安装QtDesigner工具；

1. 配置QT设计界面“Qt Designer”

Pycharm --> File --> setting --> Tools --> External Tools --> 左上角 + 号Add ，填入对应参数：

• Name：工具名，自定义，可填 QtDesigner
• Program：运行程序，选择designer.exe

参考路径：C:\Users\你的用户名\AppData\Local\Programs\Python\Python37\Lib\site-packages\pyqt5_tools\Qt\bin\designer.exe

• Working directory：工作路径，默认即可

参考路径：C:\Users\你的用户名\AppData\Local\Programs\Python\Python37\Lib\site-packages\pyqt5_tools\Qt\bin

2. 配置.ui转.py工具“pyUIC”

同上操作，新添加一个Tools，填入对应参数：
Name：工具名，自定义，可填 PyUIC

• Program：运行程序，选择uic.exe

参考路径：C:\Users\你的用户名\AppData\Local\Programs\Python\Python37\Scripts\pyuic5.exe

• Arguments：参数，填入：$FileName$ -o $FileNameWithoutExtension$.py
• Working directory：工作路径，$ProjectFileDir$

完成上述两项操作后，记得Apply 和 OK ！！！

使用说明

---

【简单】使用 pyQT5 设计 GUI

新建窗体

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 新建应用对象

window = QWidget()  # 新建窗体
window.setWindowTitle("sb")  # 窗体标题
window.resize(500, 500)  # 窗体初始化大小
window.move(0, 0)  # 窗体初始化位置

label = QLabel(window)  # 新建窗体标签对象
label.setText("sb")  # 标签内容
label.move(200, 200)  # 标签在窗体中的位置

window.show()  # 显示窗体

sys.exit(app.exec_())  # 循环运行应用对象

类继承

from PyQt5.Qt import *


class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def __init__(self):  # 类初始化
        super().__init__()  # 继承超类 QWidget，详见下面链接
        self.setWindowTitle("Window-Title")  # 窗体标题
        self.resize(500, 500)  # 窗体初始化尺寸
        self.setup_ui()  # 初始化运行的函数

    def QObject继承结构测试(self):
        # mros = QObject.__subclasses__()  # 返回所有子类
        mros = QObject.mro()  # ？？？
        for mro in mros:
            print(mro)

    def setup_ui(self):
        self.QObject继承结构测试()
        self.QObject类型判定()
        self.QObject对象的父子关系操作()
        self.QObject信号的操作()
        self.QObject对象名称和属性的操作()
        self.QObject对象释放()

    def QObject类型判定(self):
        label1 = QLabel(self)  # 新建窗体标签对象
        label1.setText("sb")  # 标签内容
        label1.move(100, 100)  # 标签在窗体中的位置

        label2 = QLabel(self)  # 新建窗体标签对象
        label2.setText("sbbbbb")  # 标签内容
        label2.move(0, 150)  # 标签在窗体中的位置
        # del label2  # 直接删除对象
        label2.deleteLater()  # 删除父类对象下的所有子对象，详见下面链接

        btn = QPushButton(self)  # 新建窗体按钮对象
        btn.setText("一个按钮")  # 按钮内容
        btn.move(200, 200)  # 按钮在窗体内的位置

        # for widget in self.findChildren(QLabel):
        for widget in self.children():  # 遍历所有子类（widget：控件），即遍历所有窗体控件
            print(widget)  # 查看所有控件
            if widget.isWidgetType():  # 如果子类是控件
                # if widget.inherits("QLabel"):  # 如果子类继承于类 QLabel，即如果控件是一个标签
                widget.setStyleSheet("background-color: cyan;")  # 设置对象背景色

    def QObject对象的父子关系操作(self):
        obj1 = QObject()

        self.obj1 = obj1
        obj2 = QObject()
        obj2.setParent(obj1)  # 指定父类窗体

        # 监听obj2对象被释放
        obj2.destroyed.connect(lambda: print("obj2对象被释放了"))
        del self.obj1  # 直接删除对象，即释放对象

    def QObject信号的操作(self):
        def destroy_cao(obj):
            print("对象被释放了", obj)

        def obj_name_cao(name):
            print("对象名称发生了改变", name)

        self.obj = QObject()  # 创建一个对象

        self.obj.destroyed.connect(destroy_cao)  # 事件与函数绑定，此处是对象被释放事件
        self.obj.objectNameChanged.connect(obj_name_cao)  # 事件与函数绑定，从此处是对象名被改变事件
        self.obj.objectNameChanged.disconnect(obj_name_cao)  # 事件与函数解绑定

        self.obj.setObjectName("改变对象名字")  # 改变对象名
        print(self.obj.receivers(self.obj.objectNameChanged))  # 查看对象接收器中接收到的对象数量
        # del self.obj  # 直接删除对象，即释放对象

        print(self.obj.signalsBlocked(), "还没被阻断")  # 判断信号是否被临时阻断
        self.obj.blockSignals(True)  # 临时阻断信号与槽函数的连接
        print(self.obj.signalsBlocked(), "信号被阻断")  # 判断信号是否被临时阻断
        self.obj.blockSignals(False)  # 恢复被临时阻断的信号与槽函数的连接
        print(self.obj.signalsBlocked(), "信号恢复了")

        # *************信号与槽案例***************开始
        def cao():
            print("按钮被点击")

        btn = QPushButton(self)  # 新建按钮对象
        btn.setText("点击我")  # 按钮内容

        btn.clicked.connect(cao)  # 事件与函数绑定，此处是按钮被点击事件
        # *************信号与槽案例***************结束

    def QObject继承结构测试(self):
        # mros = QObject.__subclasses__()  # 返回所有子类
        mros = QObject.mro()  # ？？？
        for mro in mros:
            print(mro)

    def QObject对象名称和属性的操作(self):
        # *************案例演示***************开始
        with open("QObject.qss", "r") as f:  # 打开并读取 qss 文件
            qApp.setStyleSheet(f.read())

        label = QLabel(self)  # 新建窗体标签对象
        label.setObjectName("notice")  # 对象改名
        ## setProperty (String prop, String value)
        ## - prop - 系统属性的名称
        ## - value - 系统属性的值
        label.setProperty("notice_level", "warning")  # 设置指定键对值的系统属性
        label.setText("warning")  # 标签内容
        label.setStyleSheet("font-size: 20px; color: red;")  # 设置标签样式

        label2 = QLabel(self)  # 新建窗体标签对象
        label2.move(100, 100)  # 标签在窗体的位置
        label2.setObjectName("notice")  # 对象改名
        label2.setProperty("notice_level", "error")  # 设置指定键对值的系统属性
        label2.setText("error")  # 标签内容

        print(label.dynamicPropertyNames())  # 查看对象键对值的系统属性
        print(label2.parentWidget())  # 查看 label2 的父类控件
        # *************案例演示***************结束

    def QObject对象释放(self):
        obj1 = QObject()  # 新建对象
        self.obj1 = obj1  # 把对象赋值给父类
        obj2 = QObject()  # 新建对象
        obj3 = QObject()  # 新建对象

        obj3.setParent(obj2)  # 指定父类窗体
        obj2.setParent(obj1)  # 指定父类窗体

        obj1.destroyed.connect(lambda: print("obj1被释放了"))  # 事件与函数绑定，此处是对象释放事件
        obj2.destroyed.connect(lambda: print("obj2被释放了"))  # 事件与函数绑定，此处是对象释放事件
        obj3.destroyed.connect(lambda: print("obj3被释放了"))  # 事件与函数绑定，此处是对象释放事件

        # del obj2  # 直接删除对象，即释放对象
        # 由于上面指定 obj3 的父类为 obj2，所以执行语句 obj2.deleteLater() 释放 obj2，其子类 obj3 也会被释放
        obj2.deleteLater()  # 删除父类对象下的所有子对象，详见下面链接

        print(obj1.children())  # 查看 obj1 的子类，即 obj2，与下句运行结果相同
        print(obj2)  # 查看 obj2


if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)

    window = Window()  # 新建一个窗体对象
    # window = QWidget()

    window.show()  # 展示窗体

    print(window.childAt(255, 255))  # 查看位于窗体内坐标(255, 255) 处的子类
    print(window.childrenRect())  # 查看窗体子类结构，即(x坐标，y坐标，宽，高)

    sys.exit(app.exec_())  # 循环运行应用对象
    

参考：
QObject
Python super() 函数
Qt deletelater函数分析
Setparent函数用法技巧

定时器事件

from PyQt5.Qt import *
import sys

# class MyObject(QObject):
#     def timerEvent(self, evt):  # 定时器响应函数
#         print(evt, "1")

class MyLabel(QLabel):
    def __init__(self, *args, **kwargs):  # 类初始化函数
        super().__init__(*args, **kwargs)  # 继承超类 QLabel，详见下面链接
        self.setText("10")  # 初始化标签内容
        self.move(100, 100)  # 初始化标签在窗体内的位置
        self.setStyleSheet("font-size: 22px;")  # 初始化标签样式

    def setSec(self, sec):
        self.setText(str(sec))

    def startMyTimer(self, ms):
        self.timer_id = self.startTimer(ms)  # 创建并开始一个定时器

    def timerEvent(self, *args, **kwargs):  # 定时器响应函数
        print("计时一次")

        current_sec = int(self.text())  # 获取当前的标签的内容
        current_sec -= 1
        self.setText(str(current_sec))  # 更新标签内容

        if current_sec == 0:
            print("停止")
            self.killTimer(self.timer_id)  # 销毁一个计时器

class MyWidget(QWidget):
    def timerEvent(self, *args, **kwargs):
        current_w = self.width()
        current_h = self.height()
        self.resize(current_w + 10, current_h + 10)

app = QApplication(sys.argv)  # 新建一个应用程序对象

window = MyWidget()  # 类实例化
window.setWindowTitle("QObject定时器的使用")  # 窗体标题
window.resize(500, 500)  # 初始化窗体尺寸
window.startTimer(1000)  # 启动一个定时器，定时器启动间隔 1000毫秒，即每 1 秒调用一次类

label = MyLabel(window)  # 类实例化
label.setSec(5)  # 调用类内函数 setSec()，即修改标签内容为 "5"
label.startMyTimer(1000)  # 调用类内函数 startMyTimer()，即设定定时器间隔为 1000毫秒

window.show()  # 展示窗体

sys.exit(app.exec_())  # 循环运行应用对象

键盘鼠标事件

from PyQt5.Qt import *
import sys

class MyLabel(QLabel):
    def enterEvent(self, *args, **kwargs):  # 鼠标进入事件响应函数
        print("鼠标进入")
        self.setText("鼠标进入")

    def leaveEvent(self, *args, **kwargs):  # 鼠标离开事件响应函数
        print("鼠标离开")
        self.setText("鼠标离开")

    def keyPressEvent(self, evt):  # 键盘按下事件响应函数
        # QKeyEvent
        print("检测到键盘被按下")

        if evt.key() == Qt.Key_Tab:  # 如果被按下的是 Tab 键
            print("----- 被点击的是 Tab 键")

        if evt.modifiers() == Qt.ControlModifier and evt.key() == Qt.Key_S:  # 获取组合键
            print("----- 组合键被按下，ctrl + S 被点击")

        if evt.modifiers() == Qt.ControlModifier | Qt.ShiftModifier and evt.key() == Qt.Key_A:  # 获取组合键
            print("----- 组合键被按下，ctrl + Shift + A 被点击")

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = QWidget()  # 创建一个窗体控件
window.setWindowTitle("鼠标操作案例")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

label = MyLabel(window)  # 类实例化
label.resize(200, 200)  # 标签尺寸
label.move(100, 100)  # 标签在窗体内位置
label.setStyleSheet("background-color: cyan;")  # 标签样式
label.grabKeyboard()  # 获取键盘事件

window.show()  # 展示窗体控件

sys.exit(app.exec_())  # 循环运行应用对象

层级关系调整

from PyQt5.Qt import *
import sys

class Label(QLabel):  # 继承于标签 QLabel 的类
    def mousePressEvent(self, evt):  # 鼠标按下事件响应函数
        self.raise_()  # 让标签升层

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = QWidget()  # 新建窗体对象
window.setWindowTitle("层级关系调整")  # 窗体标题
window.resize(500, 500)  # 初始化窗体尺寸

label1 = Label(window)  # 类实例化
label1.setText("标签1")  # 标签内容
label1.resize(200, 200)  # 标签尺寸
label1.setStyleSheet("background-color: red;")  # 标签样式

label2 = Label(window)  # 类实例化
label2.setText("标签2")  # 标签内容
label2.resize(200, 200)  # 标签尺寸
label2.setStyleSheet("background-color: green;")  # 标签样式
label2.move(100, 100)  # 标签位置

# label1.lower()  # 让标签1 降层
# label1.raise_()  # 让标签1 升层
# label2.stackUnder(label1)  # 让标签2 位于标签1 下层

window.show()  # 展示控件

sys.exit(app.exec_())  # 循环运行应用对象

窗体状态

from PyQt5.Qt import *
import sys

class Window(QWidget):  # 继承于控件 QWidget 的类
    def mousePressEvent(self, QMouseEvent):  # 鼠标按下事件响应函数
        if self.isMaximized():  # 如果窗体处于最大化
            self.showNormal()  # 窗体正常化
        else:
            self.showMaximized()  # 窗体最大化

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = Window()  # 类实例化
window.resize(500, 500)  # 窗体尺寸
window.setWindowTitle("w1")  # 窗体标题

icon = QIcon("xxx.png")  # 创建图标对象
window.setWindowIcon(icon)  # 设置窗体图标
print(window.windowIcon())

window.setWindowOpacity(0.9)  # 设置窗体透明度
print(window.windowOpacity())

# window.windowState() ： 读取窗体状态
# Qt.WindowNoState : 窗体无状态，即默认状态
print(window.windowState() == Qt.WindowNoState)  # 判断窗口状态
# window.setWindowState(Qt.WindowMinimized)  # 设置窗体状态，此处是最小化
# window.setWindowState(Qt.WindowMaximized)  # 设置窗体状态，此处是最大化（最大化有标题栏）
# window.setWindowState(Qt.WindowFullScreen)  # 设置窗体状态，此处是全屏化（全屏化没有标题栏）
# window.setWindowState(Qt.WindowActive)  # 设置窗体状态，此处是激活状态

window.show() # 展示控件

sys.exit(app.exec_())  # 循环运行应用对象

Qt::WindowStates 类型有以下几个取值：

• Qt::WindowNoState：无标志，正常状态，默认状态。

• Qt::WindowMinimized：最小化状态。

• Qt::WindowMaxmized：最大化状态。

• Qt::WindowFullScreen：全屏状态。

• Qt::WindowActive：激活状态。

参考：
Qt 常用类 （9）—— QWidget

窗体大小

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = QWidget()  # 创建一个窗体对象
window.move(200, 100)  # 初始化窗体在屏幕中的位置
# window.resize(500, 500)  # 初始化窗体尺寸
window.setFixedSize(500, 500)  # 窗体固定尺寸
# window.setGeometry(0, 0, 500, 150)  # 设置窗体位置与大小，输入参数：(x坐标，y坐标，宽，高)，如果上面已设置过，此语句不起作用
print(window.x())
print(window.width())
print(window.geometry())


label = QLabel(window)  # 新建窗体内标签对象
label.setText("sb")  # 标签内容
label.move(100, 100)  # 标签在窗体内的位置
label.setStyleSheet("background-color: cyan;")  # 标签样式

def changeCao():
    new_content = label.text() + "+1 "
    label.setText(new_content)  # 标签内容
    # label.resize(label.width() + 100, label.height())  # 手动改变标签尺寸
    label.adjustSize()  # 自动调整标签尺寸

btn = QPushButton(window)  # 新建窗体内按钮对象
btn.setText("增加内容")  # 按钮内容
btn.move(100, 300)  # 按钮在窗体中的位置
btn.clicked.connect(changeCao)  # 事件与函数绑定，此处是按钮被点击事件

window.show()  # 展示窗体

sys.exit(app.exec_())  # 循环运行应用对象

【案例】无边框窗体

from PyQt5.Qt import *
import sys

class Window(QWidget):  # 继承于控件 QWidget 的类
    def __init__(self, *args, **kwargs):  # 类初始化函数
        super().__init__(*args, **kwargs)  # 继承超类 QWidget
        self.setWindowFlags(Qt.FramelessWindowHint)  # 设置窗口属性，此处是设置窗体为无边框，不可拖动拖拽拉伸
        self.setWindowOpacity(0.9)  # 窗体透明度
        self.setWindowTitle("顶层窗口操作-案例")  # 窗体标题
        self.resize(500, 500)  # 窗体尺寸

        # 公共数据
        self.top_margin = 10
        self.btn_w = 80
        self.btn_h = 40

        self.setup_ui()  # 调用函数

    def setup_ui(self):
        # 添加三个子控件 - 窗口的右上角
        close_btn = QPushButton(self)  # 创建按钮对象
        self.close_btn = close_btn  # 把对象传递给父类
        close_btn.setText("关闭")  # 按钮内容
        close_btn.resize(self.btn_w, self.btn_h)  # 按钮尺寸

        max_btn = QPushButton(self)
        self.max_btn = max_btn
        max_btn.setText("最大化")
        max_btn.resize(self.btn_w, self.btn_h)

        mini_btn = QPushButton(self)
        self.mini_btn = mini_btn
        mini_btn.setText("最小化")
        mini_btn.resize(self.btn_w, self.btn_h)

        def max_normal():
            if self.isMaximized():
                self.showNormal()
                max_btn.setText("最大化")
            else:
                self.showMaximized()
                max_btn.setText("恢复")

        close_btn.pressed.connect(self.close)  # 事件与函数绑定，此处是按钮被按下事件
        max_btn.pressed.connect(max_normal)  # 事件与函数绑定，此处是按钮被按下事件
        mini_btn.pressed.connect(self.showMinimized)  # 事件与函数绑定，此处是按钮被按下事件

    def resizeEvent(self, QResizeEvent):  # 窗体尺寸变化事件响应函数
        print("窗口大小发生了改变")
        window_w = self.width()

        close_btn_x = window_w - self.btn_w
        close_btn_y = self.top_margin
        self.close_btn.move(close_btn_x, close_btn_y)  # 改变关闭按钮在窗体中的位置

        max_btn_x = close_btn_x - self.btn_w
        max_btn_y = self.top_margin
        self.max_btn.move(max_btn_x, max_btn_y)  # 改变最大化按钮在窗体中的位置

        mini_btn_x = max_btn_x - self.btn_w
        mini_btn_y = self.top_margin
        self.mini_btn.move(mini_btn_x, mini_btn_y)  # 改变最小化按钮在窗体中的位置

    def mousePressEvent(self, QMouseEvent):  # 鼠标按下事件响应函数
        pass

    def mouseMoveEvent(self, QMouseEvent):  # 鼠标移动事件响应函数
        pass

    def mouseReleaseEvent(self, QMouseEvent):  # 鼠标释放事件响应函数
        pass

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = Window()  # 新建窗体对象
window.show()  # 展示窗体

sys.exit(app.exec_())  # 循环运行应用对象

参考
setWindowFlags设置窗口属性

【案例】窗体综合

from PyQt5.Qt import *
import sys

# class Label(QLabel):
#     def mousePressEvent(self, QMouseEvent):
#         self.setStyleSheet("background-color: red;")

class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def mousePressEvent(self, evt):  # 鼠标按下事件响应函数
        local_x = evt.x()  # 获取鼠标 x 坐标
        local_y = evt.y()  # 获取鼠标 y 坐标
        sub_widget = self.childAt(local_x, local_y)  # 查看位于窗体内坐标(x 坐标, y 坐标)处的子类
        if sub_widget is not None:  # 如果该坐标处有子类
            sub_widget.setStyleSheet("background-color: red;")  # 设置对象样式
        print(local_x, local_y, "被点击了")


app = QApplication(sys.argv)  # 创建一个应用程序对象

window = Window()  # 新建一个窗体对象
window.setWindowTitle("父子关系案例")  # 窗体标题
window.resize(500, 500)  # 初始化窗体尺寸

for i in range(1, 11):  # 循环生成 10 个标签
    label = QLabel(window)  # 新建窗体内标签对象
    label.setText("标签" + str(i))  # 标签内容
    label.move(40*i, 40*i)  # 标签在窗体内的位置

window.show()  # 展示窗体

sys.exit(app.exec_())  # 循环运行应用对象

控件交互

from PyQt5.Qt import *
import sys

class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def paintEvent(self, evt):  # 绘制事件响应函数
        print("窗口被绘制了")
        return super().paintEvent(evt)

class Btn(QPushButton):  # 新建按钮类
    def paintEvent(self, evt):  # 绘制事件响应函数
        print("按钮被绘制了")
        return super().paintEvent(evt)

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = Window()  # 类实例化
window.setWindowTitle("交互状态")  # 窗体标题
window.resize(500, 500)  # 初始化窗体尺寸

btn = Btn(window)  # 类实例化
btn.setText("按钮")  # 按钮内容
btn.destroyed.connect(lambda : print("按钮被释放了"))  # 事件与函数绑定，此处是按钮被释放事件

# btn.setVisible(True)  # 让按钮可见
# btn.setHidden(True)  # 让按钮不可见
# btn.hide()  # 隐藏按钮

# btn.deleteLater()  # 删除父类对象下的所有子对象
# btn.setAttribute(Qt.WA_DeleteOnClose, True)  # 设置控件属性，此处是释放按钮，详见下面参考链接
# btn.close()  # 关闭按钮控件

window.show()  # 展示窗体

sys.exit(app.exec_())  # 循环运行应用对象

参考：
Qt 窗口属性简介之Qt::WA_DeleteOnClose

【案例】简单登录界面

from PyQt5.Qt import *

class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def __init__(self):  # 类初始化函数
        super().__init__()  # 继承超类 QWidget
        self.setWindowTitle("简单登录界面")  # 窗体标题
        self.resize(500, 500)  # 初始化窗体尺寸
        self.setup_ui()  # 调用函数

    def setup_ui(self):
        # 添加三个子控件
        label = QLabel(self)  # 新建窗体内标签
        label.setText("请输入登录密码：")
        label.move(100, 50)

        le = QLineEdit(self)  # 新建窗体内输入框
        # le.setText("文本框")
        le.move(100, 100)

        btn = QPushButton(self)  # 新建窗体内按钮
        btn.setText("登录")
        btn.move(100, 150)
        btn.setEnabled(False)  # 设置按钮状态，此处是让按钮不可按

        def text_cao(text):
            print("文本内容发生了改变", text)
            btn.setEnabled(len(text) > 0)  # 让按钮可按
            if len(text) == 0:
                label.setText("请输入登录密码：")  # 复原标签内容
            if text == "2333":  # 密码正确直接登录
                label.setText("登录成功")
            else:
                pass
            label.show()  # 展示标签
            label.adjustSize()  # 自动调整标签尺寸

        def check():
            print("按钮被点击了")
            content = le.text()  # 获取文本框内容
            if content != "2333":
                label.setText("登录失败")
            else:
                pass
            label.show()  # 展示标签
            label.adjustSize()  # 自动调整标签尺寸

        le.textChanged.connect(text_cao)  # 事件与函数绑定，此处是文本被改变事件
        btn.pressed.connect(check)  # 事件与函数绑定，此处是按钮被按下事件
        btn.pressed.connect(check)  # 事件与函数绑定，此处是按钮被按下事件

if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)  # 创建一个应用程序对象
    window = Window()  # 类实例化
    window.show()  # 展示窗体
    sys.exit(app.exec_())  # 循环运行应用对象

焦点控制

from PyQt5.Qt import *
import sys

class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def mousePressEvent(self, evt):  # 鼠标点击事件响应函数
        print(self.focusWidget())  # 查看当前焦点所在文本框
        # self.focusNextChild()  # 聚焦下一个子类控件
        # self.focusPreviousChild()  # 聚焦上一个子类控件
        self.focusNextPrevChild(True)  # 聚焦到上(False)/下(True)一个子类控件

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = Window()  # 类实例化
window.setWindowTitle("焦点控制")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

le1 = QLineEdit(window)  # 新建窗体内文本框
le1.move(50, 50)  # 文本框在窗体内位置

le2 = QLineEdit(window)
le2.move(100, 100)

le3 = QLineEdit(window)
le3.move(150, 150)

QWidget.setTabOrder(le1, le2)  # 设置 Tab 键指令，实现文本框间跳转
QWidget.setTabOrder(le2, le3)

le1.setFocus()  # 对指定的控件设置焦点，此处为聚焦于文本框1
# 下面还不知道是干嘛用的
# le2.setFocusPolicy(Qt.TabFocus)
# le2.setFocusPolicy(Qt.ClickFocus)
# le2.setFocusPolicy(Qt.StrongFocus)  # 设置了 strongFocus 的控件会接收来自Tab键和鼠标点击的焦点
#
# le2.setFocus()
# le2.clearFocus()

window.show()  # 展示窗体

print(le1)  # 查看三个文本框信息
print(le2)
print(le3)
#
# le2.setFocus()
# le1.clearFocus()

sys.exit(app.exec_())   # 循环运行应用对象

事件响应函数

from PyQt5.Qt import *

class Window(QWidget):  # 新建窗体类，原理同 window = QWidget()
    def __init__(self):  # 类初始化函数
        super().__init__()  # 继承超类 QWidget
        self.setWindowTitle("事件消息的学习")  # 窗体标题
        self.resize(500, 500)  # 窗体尺寸
        self.setup_ui()  # 调用函数

    def setup_ui(self):
        pass

    def showEvent(self, QShowEvent):  # 控件展示事件响应函数
        print("窗口被展示了出来")

    def closeEvent(self, QCloseEvent):  # 控件关闭事件响应函数
        print("窗口被关闭了")

    def moveEvent(self, QMoveEvent):  # 控件移动事件响应函数
        print("窗口被移动了")

    def resizeEvent(self, QResizeEvent):  # 控件尺寸变化事件响应函数
        print("窗口改变了尺寸大小")

    def enterEvent(self, QEvent):  # 鼠标进入控件事件响应函数
        print("鼠标进来了")
        self.setStyleSheet("background-color: yellow;")

    def leaveEvent(self, QEvent):  # 鼠标离开控件事件响应函数
        print("鼠标移开了")
        self.setStyleSheet("background-color: green;")

    def mousePressEvent(self, QMouseEvent):  # 鼠标被按下事件响应函数
        print("鼠标被按下")

    def mouseReleaseEvent(self, QMouseEvent):  # 鼠标被释放事件响应函数
        print("鼠标被释放")

    def mouseDoubleClickEvent(self, QMouseEvent):  # 鼠标双击事件响应函数
        print("鼠标双击")

    def mouseMoveEvent(self, QMouseEvent):  # 鼠标移动事件响应函数
        print("鼠标移动了")

    def keyPressEvent(self, QKeyEvent):  # 键盘按下事件响应函数
        print("键盘上某一个按键被按下了")

    def keyReleaseEvent(self, QKeyEvent):  # 键盘松开事件响应函数
        print("键盘上某一个按键被释放了")

if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)  # 创建一个应用程序对象
    window = Window()  # 类实例化
    window.show()  # 展示窗体
    sys.exit(app.exec_())  # 循环运行应用对象

在这里插入代码片

参考：
从Qt到PyQt - event()事件处理机制
QMainWindow
PyQt5 实现状态栏(statusBar）显示和隐藏功能

控件信息提示 [状态栏、help 按钮]

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
# window = QWidget()
window = QMainWindow()  # 新建主应用程序窗口
window.setWindowTitle("信息提示案例")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸
window.setWindowFlags(Qt.WindowContextHelpButtonHint)  # 设置窗口属性，此处是在窗体标题栏增加 help 按钮
window.statusBar()  # 新建状态栏
window.setStatusTip("您已进入本窗口")  # 添加状态栏提示文本，即当鼠标停留在窗口控件身上之后, 在状态栏提示的一段文本
print(window.statusTip())

label = QLabel(window)  # 新建窗体内标签
label.setText("sb")  # 标签内容
label.setStatusTip("这是标签")  # 标签状态栏提示，鼠标停留在此处，状态栏有对应提示
label.setToolTip("这是一个提示标签")  # 标签工具提示，此处是鼠标悬停一段时间会有提示信息出现
# label.setToolTipDuration(2000)  # 控件的工具提示停留时间，单位毫秒，此处是鼠标悬停在标签处后出现提示信息 2 秒，然后消失
print(label.toolTip())
print(label.toolTipDuration())

label.setWhatsThis("这是标签1111")  # 标签 help 按钮提示

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

窗体尺寸控制

from PyQt5.Qt import * 
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体控件
window.setWindowTitle("最小尺寸最大尺寸限定")  # 窗体标题
# window.resize(500, 500)  # 窗体尺寸
# window.setFixedSize(500, 500)  # 窗体固定尺寸
window.setMinimumSize(200, 200)  # 窗体最小尺寸
window.setMaximumSize(500, 500)  # 窗体最大尺寸
# window.setMinimumWidth(500)  # 窗体最小宽度
# window.setMaximumWidth(800)  # 窗体最大宽度
# window.setMinimumHeight(800)  # 窗体最大高度
# window.setMaximumHeight(800)  # 窗体最大高度
window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

各种按钮功能测试

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体对象
window.setWindowTitle("按钮的功能测试-抽象类")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

btn = QPushButton(window)  # 新建窗体内按钮
btn.move(300, 200)
# *************文本操作***************开始
def plus_one():
    print("加一")
    num = int(btn.text()) + 1
    btn.setText(str(num))

btn.setText("1")  # 按钮内容
btn.pressed.connect(plus_one)  # 事件与函数绑定，此处是按钮按下事件
# *************文本操作***************结束

# *************图标操作***************开始
icon = QIcon("xxx.png")  # 新建图标对象
btn.setIcon(icon)  # 设置按钮图标
size = QSize(20, 20)
btn.setIconSize(size)  # 设置按钮图标大小
print(btn.icon())
print(btn.iconSize())
# *************图标操作***************结束

# *************快捷键的设定***************开始
btn.setShortcut("Alt+c")
# *************快捷键的设定***************结束

# *************自动重复***************开始
btn.setAutoRepeat(True)  # 对象自动重复，此处是长按按钮实现重复按下按钮
btn.setAutoRepeatDelay(200)  # 重复延时
btn.setAutoRepeatInterval(100)  # 重复间隔
print(btn.autoRepeat())
print(btn.autoRepeatInterval())
print(btn.autoRepeatDelay())
# *************自动重复***************结束

# *************按钮状态***************开始
push_button = QPushButton(window)  # 新建窗体内按钮
push_button.setText("这是QPushButton")  # 按钮内容
push_button.move(300, 100)  # 按钮在窗体内的位置

radio_button = QRadioButton(window)
radio_button.setText("这是一个radio")
radio_button.move(100, 150)

checkbox = QCheckBox(window)
checkbox.setText("这是checkbox")
checkbox.move(100, 200)

push_button.setStyleSheet("QPushButton:pressed {background-color: red;}")  # 窗体样式

# 把三个按钮, 置为按下状态
push_button.setDown(True)
radio_button.setDown(True)
checkbox.setDown(True)

push_button.setCheckable(True)  # 设定按钮为可以选择
print(push_button.isCheckable())
print(radio_button.isCheckable())
print(checkbox.isCheckable())

# 设定按钮为选定状态
radio_button.setChecked(True)
push_button.setChecked(True)
checkbox.setChecked(True)

print(push_button.isChecked())
print(radio_button.isChecked())
print(checkbox.isChecked())

def cao():
    push_button.toggle()  # 让按钮处于选定/不选定状态
    radio_button.toggle()
    checkbox.toggle()
    push_button.setChecked(not push_button.isChecked())

btn.pressed.connect(cao)  # 事件与函数绑定，此处是按钮按下事件


push_button.setEnabled(True)
radio_button.setEnabled(True)
checkbox.setEnabled(True)
# *************按钮状态***************结束

# 2.3 展示控件
# *************排他性设置***************开始
for i in range(0, 3):
    btn5 = QCheckBox(window)
    btn5.setText("btn" + str(i))
    btn5.move(50 * i, 50 * i)

    btn5.setAutoExclusive(True)  # 设置排他性，即三个按钮只能选其一
    print(btn5.autoExclusive())
    print(btn5.isCheckable())
    btn5.setCheckable(True)
# *************排他性设置***************结束

# *************按钮模拟点击***************开始
btn9 = QPushButton(window)
btn9.setText("这是按钮")
btn9.move(200, 200)
btn9.pressed.connect(lambda :print("点击了这个按钮"))
btn9.click()
btn9.animateClick(2000)
# *************按钮模拟点击***************结束

class Btn(QPushButton):
    def hitButton(self, point):  # 按钮按下事件响应函数
        import math
        print(point)
        if point.x() > self.width() / 2:
            return True
        return False

        # 通过给定的一个点坐标, 计算与圆心的距离
        yuanxin_x = self.width() / 2
        yuanxin_y = self.height() / 2

        hit_x = point.x()
        hit_y = point.y()

        # ((x1 - x2) 平方 + (y1 - y2) 平方) 开平方
        distance = math.sqrt(math.pow(hit_x - yuanxin_x, 2) + math.pow(hit_y - yuanxin_y, 2))
        if distance < self.width() / 2:
            return True
        # 如果距离 < 半径  True
        # 返回 False
        return False

    def paintEvent(self, evt):  # 绘制事件响应函数
        super().paintEvent(evt)
        painter = QPainter(self)
        painter.setPen(QPen(QColor(100, 150, 200), 6))
        painter.drawEllipse(self.rect())

btn0 = Btn(window)  # 类实例化
btn0.move(200, 300)  # 按钮在窗体内的位置
btn0.setText("点击")  #按钮内容
btn0.resize(200, 200)
btn.setCheckable(True)
btn.pressed.connect(lambda : print("按钮被按下了"))
btn.released.connect(lambda : print("按钮鼠标被释放了"))
btn.clicked.connect(lambda value: print("按钮被点击", value))
btn0.toggled.connect(lambda value: print("按钮选中状态发生了改变", value))

window.show()  # 窗体展示
sys.exit(app.exec_())  # 循环运行应用对象

参考：
Qt5 Python GUI 编程指南

绘制事件

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体控件
window.setWindowTitle("QAbstractButton")  # 窗体标题
window.resize(300, 200)  # 窗体尺寸

class Btn(QAbstractButton):
    def paintEvent(self, evt):  # 绘制事件响应函数
        painter = QPainter(self)  # 新建画布对象
        pen = QPen(QColor(111, 200, 20), 2)  # 绘制几何图形边缘，（颜色，线粗）
        painter.setPen(pen)  # 在画布上进行绘制
        painter.drawText(25, 40, self.text())  # 绘制按钮内容
        painter.drawEllipse(0, 0, 50, 100)  # 绘制椭圆，(x坐标，y坐标，x长，y长)

btn = Btn(window)  # 新建窗体按钮
btn.setText("xxx")
btn.resize(200, 200)
btn.pressed.connect(lambda : print("点击了这个按钮"))

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

参考：
QT-QPainter介绍

右击菜单和按钮下拉菜单

from PyQt5.Qt import *
import sys

class Window(QWidget):
    def contextMenuEvent(self, evt):  # 右键菜单事件
        print("默认上下文菜单调用这个方法")
        menu = QMenu(self)

        # 子菜单 最近打开

        open_recent_menu = QMenu(menu)
        open_recent_menu.setTitle("最近打开")
        open_recent_menu.setIcon()

        # 行为动作 新建  打开  分割线 退出
        new_action = QAction()
        new_action.setText("新建")
        new_action.setIcon(QIcon("xxx.png"))
        new_action = QAction(QIcon("xxx.png"), "新建", menu)
        new_action.triggered.connect(lambda: print("新建文件"))

        open_action = QAction(QIcon("xxx.png"), "打开", menu)
        open_action.triggered.connect(lambda: print("打开文件"))

        exit_action = QAction("退出", menu)
        exit_action.triggered.connect(lambda: print("退出程序"))

        file_action = QAction("Python-GUI编程-PyQt5")

        menu.addAction(new_action)
        menu.addAction(open_action)
        open_recent_menu.addAction(file_action)
        menu.addMenu(open_recent_menu)
        menu.addSeparator()
        menu.addAction(exit_action)

        # point
        menu.exec_(evt.globalPos())
        # menu.exec_(evt.pos())

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = Window()  # 类实例化
window.setWindowTitle("按钮的功能")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

btn = QPushButton(window)  # 新建窗体内按钮对象
btn.setParent(window)  # 指定父类
btn.setText("xxx")  # 标题内容
btn.setIcon(QIcon("xxx.png"))  # 按钮图标

# *************菜单的设置***************开始
menu = QMenu(window)  # 新建窗体内菜单对象

# 子菜单 最近打开
open_recent_menu = QMenu(menu)  # 新建子菜单对象
open_recent_menu.setTitle("最近打开")  # 子菜单内容
open_recent_menu.setIcon(QIcon("xxx.png"))  # 子菜单图标

# 行为动作 新建  打开  分割线 退出
# new_action = QAction()  # 新建菜单动作对象
# new_action.setText("新建")  # 动作内容
# new_action.setIcon(QIcon("xxx.png"))  # 动作图标
new_action = QAction(QIcon("xxx.png"), "新建", menu)  # 新建菜单动作对象、内容、图标
new_action.triggered.connect(lambda :print("新建文件"))  # 动作与函数绑定

open_action = QAction(QIcon("xxx.png"), "打开", menu)
open_action.triggered.connect(lambda :print("打开文件"))

exit_action = QAction("退出", menu)
exit_action.triggered.connect(lambda :print("退出程序"))

file_action = QAction("Python-GUI编程-PyQt5")  # 新建菜单对象

# 把各菜单动作对象添加到菜单或子菜单
menu.addAction(new_action)
menu.addAction(open_action)
open_recent_menu.addAction(file_action)
menu.addMenu(open_recent_menu)
menu.addSeparator()
menu.addAction(exit_action)

btn.setMenu(menu)  # 给按钮添加下拉菜单
print(btn.menu())  # 查看按钮是否有菜单
# btn.setStyleSheet("background-color: red;")  # 按钮样式，按下有下陷且为红色
btn.setStyleSheet("QPushButton border:none;")  # 按钮样式，无边框，按下无下陷
btn.setFlat(True)  # 取消按钮突出效果
print(btn.isFlat())

# *************菜单的设置***************结束
btn2 = QPushButton(window)  # 新建窗体内按钮
btn2.setText("btn2")  # 按钮内容
btn2.move(200, 200)  # 按钮尺寸

btn2.setAutoDefault(True)  # 设置按钮选中（焦点所在）时样式，True：显示蓝色边框，False：无
print(btn.autoDefault())
print(btn2.autoDefault())
# btn2.setDefault(True) # 同 setAutoDefault()，区别详见下面参考链接

def show_menu(point):
    menu = QMenu(window)  # 新建窗体内菜单对象

    open_recent_menu = QMenu(menu)  # 新建子菜单对象
    open_recent_menu.setTitle("最近打开")  # 子菜单内容
    # open_recent_menu.setIcon()  # 子菜单图标

    # 这是菜单动作 新建  打开  分割线 退出
    # new_action = QAction()
    # new_action.setText("新建")
    # new_action.setIcon(QIcon("xxx.png"))
    new_action = QAction(QIcon("xxx.png"), "新建", menu)
    new_action.triggered.connect(lambda: print("新建文件"))

    open_action = QAction(QIcon("xxx.png"), "打开", menu)
    open_action.triggered.connect(lambda: print("打开文件"))

    exit_action = QAction("退出", menu)
    exit_action.triggered.connect(lambda: print("退出程序"))

    file_action = QAction("Python-GUI编程-PyQt5")

    menu.addAction(new_action)
    menu.addAction(open_action)
    open_recent_menu.addAction(file_action)
    menu.addMenu(open_recent_menu)
    menu.addSeparator()
    menu.addAction(exit_action)

    # point
    dest_point = window.mapToGlobal(point)
    menu.exec_(dest_point)

window.setContextMenuPolicy(Qt.CustomContextMenu)  # 给窗体添加又见菜单
window.customContextMenuRequested.connect(show_menu)  # 窗体与函数绑定，此处是绑定显示菜单

btn.show()  # 展示按钮
window.show()  # 展示窗体
btn.showMenu()  # 展示按钮菜单
sys.exit(app.exec_())  # 循环运行应用对象

参考：
QPushButton 之 default、autoDefault 分析

工具按钮

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体对象
window.setWindowTitle("QToolButton使用")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

tb = QToolButton(window)  # 新建窗体内工具按钮
tb.setText("工具按钮")
tb.setIcon(QIcon("xxx.png"))
tb.setIconSize(QSize(30, 30))  # 按钮图标尺寸
tb.setToolTip("这是一个新建按钮")  # 标签工具提示
# Qt.ToolButtonIconOnly
# 	仅显示图标
# Qt.ToolButtonTextOnly
# 	仅显示文字
# Qt.ToolButtonTextBesideIcon
# 	文本显示在图标旁边
# Qt.ToolButtonTextUnderIcon
# 	文本显示在图标下方
# Qt.ToolButtonFollowStyle
# 	遵循风格
tb.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)  # 图标按钮风格
tb.setAutoRaise(True)  # 设置图标浮动，True：浮动，无边框

menu = QMenu(tb)  # 新建按钮内菜单对象
menu.setTitle("菜单")  # 菜单标题

sub_menu = QMenu(menu)  # 新建子菜单
sub_menu.setTitle("子菜单")  # 菜单标题
sub_menu.setIcon(QIcon("xxx.png"))  # 设置图标

action1 = QAction(QIcon("xxx.png"), "行为1", menu)  # 新建菜单动作
action1.setData([1, 2, 3])  # 设置动作数据
action2 = QAction("行为2", menu)  # 新建菜单动作
action2.setData({"name": "sz"})  # 设置动作数据
action1.triggered.connect(lambda :print("点击了行为菜单选项"))  # 动作一与函数绑定

# 菜单配置
menu.addMenu(sub_menu)
menu.addSeparator()
menu.addAction(action1)
menu.addAction(action2)

tb.clicked.connect(lambda :print("工具按钮被点击了"))

tb.setMenu(menu)  # 按钮添加菜单

tb.setPopupMode(QToolButton.MenuButtonPopup)  # 设置弹出模式，详见下面链接

def do_action(action):
    print("点击了行为", action.data())

tb.triggered.connect(do_action)  # 事件与函数绑定，此处是按钮被点击事件

btn = QPushButton(window)  # 新建一个普通的按下按钮
btn.setText("一般按钮")  # 按钮内容
btn.move(100, 100)  # 按钮尺寸
btn.setFlat(True)  # 按钮突出效果
btn.setMenu(menu)  # 按钮添加菜单

# Qt.NoArrow
# 	无箭头
# Qt.UpArrow
# 	向上箭头
# Qt.DownArrow
# 	向下箭头
# Qt.LeftArrow
# 	向左箭头
# Qt.RightArrow
# 	向右箭头
tb.setArrowType(Qt.RightArrow)  # 选择箭头风格

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

参考：
QToolButton

radio 选中按钮

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象

window = QWidget()  # 创建窗体对象
window.setWindowTitle("QRadioButton-功能测试")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

red = QWidget(window)  # 新建子窗体
red.resize(200, 200)  # 窗体尺寸
red.setStyleSheet("background-color: red;")  # 窗体风格
red.move(50, 50)  # 窗体位置

green = QWidget(window)
green.resize(200, 200)
green.setStyleSheet("background-color: green;")
green.move(red.x() + red.width(), red.y() + red.height())

rb_nan = QRadioButton("男-&Male", red)  # 创建 Radio 选中按钮，其中的 & 可实现按下 Alt 时显示首字母，并实现 Alt+M 的快捷键功能
# rb_nan.setShortcut("Alt+M")  # 关联快捷键
rb_nan.move(10, 10)  # 按钮位置
rb_nan.setChecked(True)  # 设定按钮为选定状态

rb_nv = QRadioButton("女-&Female", red)
rb_nv.move(10, 50)
rb_nv.setIcon(QIcon("xxx.png"))
rb_nv.setIconSize(QSize(20, 20))
rb_nv.toggled.connect(lambda isChecked: print(isChecked))  # 查看按钮是否为选定状态

rb_nv.setAutoExclusive(True)  # 设置排他性，同一窗体内，radio 选中按钮只能选其一

rb_yes = QRadioButton("yes", green)
rb_yes.move(10, 10)
rb_no = QRadioButton("no", green)
rb_no.move(10, 50)

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

按钮组设定与管理

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体对象
window.setWindowTitle("按钮组的使用")
window.resize(500, 500)

# ------------ 创建四个单选按钮 开始 ------------
# 12 男女
r_male = QRadioButton("男", window)
r_female = QRadioButton("女", window)
r_male.move(100, 100)
r_female.move(100, 150)
r_male.setChecked(True)  # 设定按钮为选定状态

sex_group = QButtonGroup(window)  # 新建窗体按钮组
sex_group.addButton(r_male, 1)  # 往组添加元素
sex_group.addButton(r_female, 2)

# 34 是否
r_yes = QRadioButton("是", window)
r_no = QRadioButton("否", window)
r_yes.move(300, 100)
r_no.move(300, 150)

answer_group = QButtonGroup(window)  # 新建窗体按钮组
answer_group.addButton(r_yes)  # 往组添加元素
answer_group.addButton(r_no)

answer_group.setId(r_yes, 1)  # 设置组内元素 ID
answer_group.setId(r_no, 2)
# ------------ 创建四个单选按钮 结束------------

print(answer_group.id(r_yes))  # 查看组内元素 ID
print(answer_group.id(r_no))
r_no.setChecked(True)
print(answer_group.checkedId())  # 查看 ID 数量

sex_group.setExclusive(True)  # 设置排他性
# sex_group.removeButton(r_female)  # 从组内移除元素
print(sex_group.buttons())  # 查看组内按钮元素
print(sex_group.button(2))  # 查看组内第二个按钮元素
print(sex_group.checkedButton())  # 查看组内元素

def test(val):
    # print(val)
    print(sex_group.id(val))  # 查看组内元素 ID

sex_group.buttonClicked.connect(test)  # 事件与函数绑定，此处是按钮组被点击事件
# sex_group.buttonClicked[int].connect(test)  # 事件与函数绑定，此处是按钮组中某个按钮被点击事件

window.show()  # 展示控件
sys.exit(app.exec_())  # 循环运行应用对象

选中框

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体对象
window.setWindowTitle("QCheckBox 功能测试")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

# print(QCheckBox.__bases__)

cb = QCheckBox("&Python", window)  # 新建窗体内选中框
cb.setIcon(QIcon("xxx.png"))  # 选中框图标
cb.setIconSize(QSize(60, 60))  # 图标尺寸
cb.setTristate(True)  # 打开选中框三态支持，详见下面参考链接
cb.setChecked(True)  # 设定按钮为选定状态
cb.setCheckState(Qt.PartiallyChecked)  # 查看选中框状态，此处是查看是否为 PartiallyChecked 状态
cb.setCheckState(Qt.Checked)

# cb.stateChanged.connect(lambda state: print(state))  # 事件于函数绑定，此处是状态改变事件
cb.toggled.connect(lambda isChecked: print(isChecked))  # 事件于函数绑定，此处是是否为选中状态事件

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

参考;
Qt之QCheckBox

输入框

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体对象
window.setWindowTitle("QLineEdit功能测试")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

le_a = QLineEdit(window)  # 新建窗口内输入框
le_a.move(100, 200)

le_b = QLineEdit(window)
le_b.move(100, 300)

le_b.setEchoMode(QLineEdit.PasswordEchoOnEdit)  # 设置文本框的回显模式，详见下面参考链接
print(le_b.echoMode())  # 查看文本框的回显模式

copy_btn = QPushButton(window)  # 新建窗体内按钮
copy_btn.setText("复制")
copy_btn.move(100, 400)

def copy_cao():
    content = le_a.text()  # 获取文本框a, 内容
    # 2. 把上面获取到的内容, 设置到文本框B里面
    le_b.setText(content)
    le_b.setText("")
    le_b.insert(content)  # 文本框插入内容
    print(le_b.text())
    print(le_b.displayText())
    print(le_b.isModified())
    le_b.setModified(False)  # 设置修改状态

copy_btn.clicked.connect(copy_cao)  # 事件与函数绑定，此处是按钮被点击事件

le_a.setMaxLength(3)  # 最大长度限制
print(le_a.maxLength())
le_a.setReadOnly(False)  # 设置为只读
le_a.setText("2333")  # 输入框内容

# le_b 设置掩码
# 总共输入5 位  左边 2(必须是大写字母) - 右边 2(必须是一个数字)
# le_b.setInputMask(">AA-99;#")
# le_b.setInputMask("9999-9999999;0")

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

参考：
setEchoMode()设置模式

输入框内容编辑

from PyQt5.Qt import *
import sys

app = QApplication(sys.argv)  # 创建一个应用程序对象
window = QWidget()  # 新建窗体
window.setWindowTitle("QLineEdit-功能测试")  # 窗体标题
window.resize(500, 500)  # 窗体尺寸

le = QLineEdit(window)  # 新建窗体内输入框
le.move(100, 100)  # 输入框位置
le.resize(300, 300)  # 输入框尺寸
le.setContentsMargins(100, 0, 0, 0)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用
le.setStyleSheet("background-color: cyan;")  # 输入框样式
le.setTextMargins(0, 0, 50, 50)  # 设置左侧、顶部、右侧和底部边距，以便在布局周围使用
le.setAlignment(Qt.AlignRight | Qt.AlignBottom)  # 消除布局中的空隙，详见下面参考链接
le.setDragEnabled(True)  # 使能拖放，详见下面参考链接

le2 = QLineEdit(window)  # 新建窗体内输入框
le2.resize(50, 50)  # 窗体尺寸
le2.move(200, 0)  # 窗体位置

btn = QPushButton(window)  # 新建按钮
btn.setText("按钮")  # 按钮内容
btn.move(50, 50)  # 按钮位置
def cursor_move():
    # le.cursorBackward(True, 2)  # 光标后退
    # le.cursorForward(True, 3)  # 光标前进
    # le.cursorWordBackward(True)  # 光标后退一词
    # le.cursorWordForward(True)  # 光标前进一词
    # le.home(True)  # 光标跳至最前端
    # le.end(False)  # 光标跳至最末端
    le.setCursorPosition(len(le.text()) / 2)  # 设置光标位置
    print(le.cursorPosition())
    print(le.cursorPositionAt(QPoint(55, 105)))
    le.setText("sb "*10)
    le.setFocus()  # 对指定的控件设置焦点
    le.backspace()  # 光标处按下退格
    le.del_()  # 光标处按下 delete
    le.clear()  # 清除光标处内容
    le.copy()  # 光标处复制内容
    le.cut()  # 光标处剪切内容
    le.paste()  # 光标处粘贴内容

    le.setSelection(2, 21)  # 选中指定区域内的文本
    le.selectAll()  # 选定所有文本
    le.setSelection(0, len(le.text()))
    le.deselect()  # 取消选中任何已选中的文本
    print(le.hasSelectedText())
    print(le.selectedText())
    print(le.selectionStart())
    print(le.selectionEnd())
    print(le.selectionLength())
    pass

btn.clicked.connect(cursor_move)  # 事件与函数绑定，此处是按钮被点击事件

le.textEdited.connect(lambda val: print("文本框编辑的时候", val))  # 事件与函数绑定，此处是文本被编辑事件
le.textChanged.connect(lambda val: print("文本框内容发生改变", val))  # 事件与函数绑定，此处是文本改变事件

le.returnPressed.connect(lambda :print("回车键被按下"))  # 事件与函数绑定，此处是回车被按下事件
le.returnPressed.connect(lambda :le2.setFocus())  # 事件与函数绑定，此处是回车被按下事件
le.editingFinished.connect(lambda :print("结束编辑"))  # 事件与函数绑定，此处是编辑结束事件

le.cursorPositionChanged.connect(lambda old_Pos, new_Pos: print(old_Pos, new_Pos))  # 事件与函数绑定，此处是文本框光标移动事件
le.selectionChanged.connect(lambda : print("选中文本发生改变", le.selectedText()))  # 事件与函数绑定，此处是当前选中区域发生变化事件

le.setText("xxx")

window.show()  # 展示窗体
sys.exit(app.exec_())  # 循环运行应用对象

参考：
Qt5.9中函数setAlignment()用法
Qt之拖放
Qt之QLineEdit详解（附源码）
视图中选择选中项的操作
Qt——QLineEdit使用总结
控制QLineEdit的输入范围

【高级】使用 QtDesigner 设计 GUI

1. 创建.ui文件并使用QtDesigner完成GUI布局：
Pycharm->Tools->External Tools->QTDesigner->创建窗体，选择Wdiget->拖动控件设计界面->把文件保存到项目目录下(ui格式文件)

2. 把.ui文件转换成.py文件：
右击工程中的刚才保存的.ui文件->External Tools->pyUIc->生成.py文件->运行.py文件

---

参考：
QT+SIP+Pyqt5