devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

009.PyQt5_QObject基类_信号与槽函数_pyqt5 信号继承qobject

作者：爱喝兽奶帝天荒 | 2024-07-27 05:42:46

赞

踩

pyqt5 信号继承qobject

信号与槽函数

  • 信号（Signal）就是在特定情况下被发射（emit）的一种通告。
    • 例如一个PushButton按钮最常见的信号就是鼠标单击时发射的clicked()信号，一个ComboBox最常见的信号是选择的项变化时发射的CurrentIndexChanged()信号。GUI程序设计的主要内容就是对界面上各组件发射的特定信号进行响应，只需要知道什么情况下发射了哪些信号，然后合理地去响应和处理这些信号就可以了
  • 槽（Slot）就是对信号响应的函数。
    • 槽实质上是一个函数，它可以被直接调用。槽函数与一般的函数不同的是：槽函数可以与一个信号关联，当信号被发射时，关联的槽函数会被自动执行。Qt的类一般都有一些内建（build-in）的槽函数
    •  例如QWidget有一个槽函数close()，其功能是关闭窗口。如果将一个PushButton按钮的clicked()信号与窗体的close()槽函数关联，那么点击按钮时就会关闭窗口

  • 理解
  • 当锅开了(发出信号)，你去关火(执行槽函数)

  • 在QT中的信号与槽

  • 信号(Signal)和槽(Slot)是Qt中的核心机制,主要作用在于对象之间进行通讯
  • 信号：当一个控件的状态发生改变时, 向外界发出的信息 
    1. 控件内置的一些函数，
    2.     按下按钮 QPushButton().pressed
    3.     按下并弹起按钮 QPushButton().clicked；
    4. 也可以自定义pyqtSignal()
  • 槽：一个执行某些操作的函数/方法 
    控件内置的槽函数；也有自定义的函数/方法
  • 连接方式 
    对象.信号.connect(槽函数)
  • 所有继承自QWidget的控件都支持"信号与槽"的机制
  • 当信号发出时, 连接的槽函数会自动执行
  • 特性
    • 一个信号可以连接多个槽函数
    • 一个信号也可以连接另外一个信号
    • 信号的参数可以是任何Python类型
    • 一个槽可以监听多个信号
    • ......

QObject对象信号处理API

  • 相关API 
    1. widget.信号.connect(槽)         # 连接信号和槽
    2. obj.disconnect()                # 取消连接信号与槽，无法恢复，只能重新连接
    3. （控件.disconnect()             # 取消控件的所有信号连接）
    4. （对象.信号.disconnect()        # 取消对象指定信号的连接）
    5. widget.blockSignals(bool)       # 临时（取消）阻止指定控件所有的信号与槽的连接（True：取消，False：恢复）
    6. widget.signalsBlocked()         # 判断信号是否被阻止
    7. widget.receivers(widget.信号)   # 返回当前对象指定信号连接的槽函数数量
  • QObject对象的信号 
    1. QObject.objectNameChanged(objectName)   # 对象名称发生改变时，发射此信号
    2. QObject.destroyed(obj)                  # 对象被销毁时, 发射此信号
    3. QWidget.windowTitleChanged              # 窗口标题发生改变时，发射此信号
  • 案例1：destroyed信号。当obj对象被销毁时，打印 '对象被销毁了' 
    1. from PyQt5.Qt import *
    2. import sys
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    11.     def widget_list(self):
    12.         self.add_widget()
    15.     def add_widget(self):
    16.         obj = QObject()
    18.         def destroyed_cao():
    19.             print('对象被释放了！')
    21.         obj.destroyed.connect(destroyed_cao)
    24. if __name__ == '__main__':
    25.     app = QApplication(sys.argv)
    26.     w = Windows()
    28.     w.show()
    29.     sys.exit(app.exec_())
  • 当这段代码一运行，就会打印'对象被释放了'，是因为obj当前是局部变量，当add_widget方法被执行完之后就会被自动销毁，所以就执行了
  • 修改代码，将obj设置成w的属性，有指针指向obj的时候就不会自动销毁了。我们再通过del来手动销毁obj，从而触发destroyed信号 
    1. def add_widget(self):
    2.     self.obj = QObject()
    3.  
    4.     def destroyed_cao():
    5.         print('对象被释放了！')
    6.  
    7.     self.obj.destroyed.connect(destroyed_cao)
    8.  
    9.     print('obj对象还未销毁')
    10.     print('销毁obj对象')
    11.     del self.obj
    12.     print('obj对象被销毁了')
    '
    运行
  • 输出结果

  • 信号的参数
  • 其实我们再引用destroyed这个信号的时候可以看到它本身是有参数的

  • destroyed(self, object)这个信号中的object就是被销毁的对象，会自动传递给它所连接的槽函数，我们只需要在槽函数中添加参数(形参)接收信号传递过来的参数(实参)就可以直接使用了 
    1.     def add_widget(self):
    2.         self.obj = QObject()
    3.  
    4.         def destroyed_cao(obj):
    5.             print(obj, '对象被释放了！')
    6.  
    7.         self.obj.destroyed.connect(destroyed_cao)
    8.  
    9.         print('obj对象还未销毁')
    10.         print('销毁obj对象')
    11.         del self.obj
    12.         print('obj对象被销毁了')
    '
    运行
  • 输出结果

  • 案例2：objectNameChanged信号。对象名称发生改变时，打印 对象名称被改变了 
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def obj_name_cao(self):
    15.         print('对象名称被改变了！')
    16.  
    17.  
    18.     def add_widget(self):
    19.         obj = QObject()
    20.  
    21.         obj.objectNameChanged.connect(self.obj_name_cao)
    22.         print('对象名称还未修改')
    23.         print('修改对象名称')
    24.         obj.setObjectName('new_objname')
    25.         print('对象名称已被修改结束')
    26.  
    27.  
    28.  
    29. if __name__ == '__main__':
    30.     app = QApplication(sys.argv)
    31.     w = Windows()
    32.  
    33.     w.show()
    34.     sys.exit(app.exec_())
  • 输出结果

  • 案例3和案例2的区别，在于槽函数的位置。案例3调用的槽函数是属于window对象的函数，所以在连接槽函数的时候需要指定为 self.obj_name_cao
  • 其实在objectNameChanged信号中也是有传递参数的objectNmae

  • objectNameChanged(self, objectNmae)信号中的objectName参数是将对象修改后的新名称传递给槽函数，我们只需要在槽函数中添加参数接收这个信号传递过来的值就可以获取到对象修改后的名称 
    1. def obj_name_cao(self, newname):
    2.     print('对象名称被改变了！', newname)
    3.  
    4.  
    5. def add_widget(self):
    6.     obj = QObject()
    7.  
    8.     obj.objectNameChanged.connect(self.obj_name_cao)
    9.     print('对象名称还未修改')
    10.     print('修改对象名称')
    11.     obj.setObjectName('new_objname')
    12.     print('对象名称已被修改结束')
  • 输出结果

  • 案例3：disconnect取消信号与槽的连接，无法恢复，只能重新连接 
    1. 控件.disconnect()       # 取消控件的所有信号与槽的连接
    2. 对象.信号.disconnect()  # 取消对象指定信号与槽的连接
    • 控件.disconnect() # 取消控件的所有信号与槽的连接
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def obj_name_cao(self, newname):
    15.         print('对象名称被改变了！', newname)
    16.  
    17.     def obj_name_cao2(self, newname):
    18.         print('对象名称被改变成：！', newname)
    19.  
    20.     def destroyed_cao(self):
    21.         print('对象被释放了')
    22.  
    23.     def add_widget(self):
    24.         obj = QObject()
    25.  
    26.         obj.objectNameChanged.connect(self.obj_name_cao)
    27.         obj.objectNameChanged.connect(self.obj_name_cao2)
    28.         obj.destroyed.connect(self.destroyed_cao)
    29.         # 取消对象所有信号与槽的连接，无法恢复，只能重新连接
    30.         obj.disconnect()
    31.         
    32.         # 取消对象指定信号与槽的连接
    33.         # obj.objectNameChanged.disconnect()
    34.         
    35.         obj.setObjectName('修改后的对象名')
    36.  
    37.  
    38.  
    39. if __name__ == '__main__':
    40.     app = QApplication(sys.argv)
    41.     w = Windows()
    42.  
    43.     w.show()
    44.     sys.exit(app.exec_())
  • 输出结果

    • 对象.信号.disconnect() # 取消对象指定信号与槽的连接
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def obj_name_cao(self, newname):
    15.         print('对象名称被改变了！', newname)
    16.  
    17.     def obj_name_cao2(self, newname):
    18.         print('对象名称被改变成：！', newname)
    19.  
    20.     def destroyed_cao(self):
    21.         print('对象被释放了')
    22.  
    23.     def add_widget(self):
    24.         obj = QObject()
    25.  
    26.         obj.objectNameChanged.connect(self.obj_name_cao)
    27.         obj.objectNameChanged.connect(self.obj_name_cao2)
    28.         obj.destroyed.connect(self.destroyed_cao)
    29.         # 取消对象所有信号与槽的连接，无法恢复，只能重新连接
    30.         # obj.disconnect()
    31.         
    32.         # 取消对象指定信号与槽的连接
    33.         obj.objectNameChanged.disconnect()
    34.         
    35.         obj.setObjectName('修改后的对象名')
    36.  
    37.  
    38.  
    39. if __name__ == '__main__':
    40.     app = QApplication(sys.argv)
    41.     w = Windows()
    42.  
    43.     w.show()
    44.     sys.exit(app.exec_())
  • 输出结果

  • 结果可以看出，当用disconnect取消信号与槽的连接之后，第一次修改对象名称，没有执行槽函数
    。当重新连接信号与槽之后，第二次修改对象名称时就执行了槽函数
  • 控件.disconnect是取消当前控件所有信号与槽的连接
  • 对象.信号.disconnect是取消当前对象指定信号与槽的连接
  • 案例4：widget.blockSignals(bool) # 临时（取消）阻止指定控件所有的信号与槽的连接 
    1. widget.blockSignals(True)   # 临时取消信号与槽的连接
    2. widget.blockSignals(False)  # 恢复信号与槽的连接
    1. from PyQt5.Qt import *
    2. import sys
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    11.     def widget_list(self):
    12.         self.add_widget()
    14.     def obj_name_cao(self, newname):
    15.         print('对象名称被改变了！', newname)
    18.     def add_widget(self):
    19.         obj = QObject()
    21.         obj.objectNameChanged.connect(self.obj_name_cao)
    22.         
    23.         # 临时取消信号与槽的连接
    24.         obj.blockSignals(True)
    25.         obj.setObjectName('第一次修改对象名称')
    27.         # 恢复信号与槽的连接
    28.         obj.blockSignals(False)
    29.         obj.setObjectName('第二次修改对象名称')
    33. if __name__ == '__main__':
    34.     app = QApplication(sys.argv)
    35.     w = Windows()
    37.     w.show()
    38.     sys.exit(app.exec_())
  • 输出结果

  • 注意：widget.blockSignals()方法是取消对象所有的信号与槽连接
  • 案例5：widget.signalsBlocked() # 判断信号是否被阻止 
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def obj_name_cao(self, newname):
    15.         print('对象名称被改变了！', newname)
    16.  
    17.  
    18.     def add_widget(self):
    19.         obj = QObject()
    20.  
    21.         obj.objectNameChanged.connect(self.obj_name_cao)
    22.         
    23.         # 临时取消信号与槽的连接
    24.         obj.blockSignals(True)
    25.         obj.setObjectName('第一次修改对象名称')
    26.         
    27.         # 判断obj对象信号与槽连接是否被阻止
    28.         print('1', obj.signalsBlocked())
    29.  
    30.         # 恢复信号与槽的连接
    31.         obj.blockSignals(False)
    32.         obj.setObjectName('第二次修改对象名称')
    33.         
    34.         # 判断obj对象信号与槽连接是否被阻止
    35.         print('2', obj.signalsBlocked())
    36.  
    37.  
    38. if __name__ == '__main__':
    39.     app = QApplication(sys.argv)
    40.     w = Windows()
    41.  
    42.     w.show()
    43.     sys.exit(app.exec_())
  • 输出结果

  • 案例6：widget.receivers(widget.信号) # 返回当前对象指定信号连接的槽函数数量 
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('QObject信号与槽')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def obj_name_cao(self, newname):
    15.         print('对象名称被改变了！', newname)
    16.  
    17.     def obj_name_cao2(self, newname):
    18.         print('对象名称被改变成：！', newname)
    19.  
    20.     def add_widget(self):
    21.         obj = QObject()
    22.  
    23.         obj.objectNameChanged.connect(self.obj_name_cao)
    24.         obj.objectNameChanged.connect(self.obj_name_cao2)
    25.         
    26.         
    27.         print('开始位置：', obj.receivers(obj.objectNameChanged))
    28.         # 临时(取消)阻止该对象的所有信号与槽的连接
    29.         obj.blockSignals(True)
    30.         print('blockSignals之后：', obj.receivers(obj.objectNameChanged))
    31.         # 断开该对象所有信号与槽的连接
    32.         obj.disconnect()
    33.         print('disconnect之后：', obj.receivers(obj.objectNameChanged))
    34.  
    35. if __name__ == '__main__':
    36.     app = QApplication(sys.argv)
    37.     w = Windows()
    38.  
    39.     w.show()
    40.     sys.exit(app.exec_())
  • 输出结果

  • 实例
  1. 用户点击按钮的时候，打印“点我嘎哈？”
  • 相关知识点
    • 按钮的单击信号：clicked
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def btn_cao(self):
    15.         print('点我嘎哈？')
    16.  
    17.     def add_widget(self):
    18.         btn = QPushButton(self)
    19.         btn.setText("点击我")
    20.         btn.clicked.connect(self.btn_cao)
    21.  
    22.  
    23. if __name__ == '__main__':
    24.     app = QApplication(sys.argv)
    25.     w = Windows()
    26.  
    27.     w.show()
    28.     sys.exit(app.exec_())
  1. 在所有修改的窗口标题前，添加前缀“新标题”
  • 相关知识点
    • 设置窗口标题：setWindowTitle
    • 监听窗口标题改变信号
    • 临时取消/恢复信号与槽的连接
    1. from PyQt5.Qt import *
    2. import sys
    3.  
    4. class Windows(QWidget):
    5.     def __init__(self):
    6.         super().__init__()
    7.         self.setWindowTitle('')
    8.         self.resize(980, 500)
    9.         self.widget_list()
    10.  
    11.     def widget_list(self):
    12.         self.add_widget()
    13.  
    14.     def windowtitle_cao(self, title):
    15.         # 临时取消信号与槽的连接，防止下面修改标题进入死循环
    16.         self.blockSignals(True)
    17.         self.setWindowTitle('新标题 - ' + title)
    18.         # 恢复信号与槽的连接，为下一次修改标题做准备
    19.         self.blockSignals(False)
    20.  
    21.     def add_widget(self):
    22.         self.windowTitleChanged.connect(self.windowtitle_cao)
    23.         self.setWindowTitle('Hello')
    24.         self.setWindowTitle('World')
    25.  
    26.  
    27.  
    28. if __name__ == '__main__':
    29.     app = QApplication(sys.argv)
    30.     w = Windows()
    31.  
    32.     w.show()
    33.     sys.exit(app.exec_())
  • 注意：
  • 如果槽函数中不加blockSignals(True)临时取消信号与槽连接的API，就会由于槽函数中也有setWindowTitle信号，会无线调用槽函数，形成死循环
  • 如果槽函数中最后不加blockSignals(False)，那么程序中后面再修改标题，就不会再执行槽函数了
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号