Pyqt/Qt信号与槽的理解（三）

自定义程度较高的应用，以自己喜欢的方式定义信号和槽函数，并传递参数，其一般流程为：

定义信号

通过类成员变量定义信号对象：

class MyWidget(QWidget):  
    # 无参数的信号
    Signal_NoParameters = pyqtSignal()     
    # 带一个参数(整数)的信号        
    Signal_OneParameter = pyqtSignal(int)         
    # 带一个参数(整数或者字符串)的重载版本的信号        
    Signal_OneParameter_Overload = pyqtSignal([int],[str])  
    # 带两个参数(整数,字符串)的信号        
    Signal_TwoParameters = pyqtSignal(int,str)    
    # 带两个参数([整数,整数]或者[整数,字符串])的重载版本的信号        
    Signal_TwoParameters_Overload = pyqtSignal([int,int],[int,str]) 

定义槽函数

定义一个槽函数，它有多个不同的输入参数。

class MyWidget(QWidget):  
    def setValue_NoParameters(self):   
        '''无参数的槽函数'''  
        pass  

    def setValue_OneParameter(self,nIndex):   
        '''带一个参数(整数)的槽函数'''  
        pass

    def setValue_OneParameter_String(self,szIndex):   
        '''带一个参数(字符串)的槽函数'''  
        pass 

    def setValue_TwoParameters(self,x,y):   
        '''带两个参数(整数,整数)的槽函数'''  
        pass  

    def setValue_TwoParameters_String(self,x,szY):   
        '''带两个参数(整数,字符串)槽函数'''  
        pass

连接信号与槽函数

通过connect方法连接信号与槽函数或者可调用对象。

app = QApplication(sys.argv)   
widget = MyWidget()   
# 连接无参数的信号
widget.Signal_NoParameters.connect(self.setValue_NoParameters )                                          

# 连接带一个整数参数的信号
widget.Signal_OneParameter.connect(self.setValue_OneParameter)                                         

# 连接带一个整数参数，经过重载的信号
widget.Signal_OneParameter_Overload[int].
    connect(self.setValue_OneParameter)                              

# 连接带一个整数参数，经过重载的信号
widget.Signal_OneParameter_Overload[str].
    connect(self.setValue_OneParameter_String )                     

# 连接一个信号，它有两个整数参数
widget.Signal_TwoParameters.connect(self.setValue_TwoParameters )                                        

# 连接带两个参数(整数,整数)的重载版本的信号
widget.Signal_TwoParameters_Overload[int,int].
    connect(self.setValue_TwoParameters )                      

# 连接带两个参数(整数,字符串)的重载版本的信号
widget.Signal_TwoParameters_Overload[int,str].
    connect(self.setValue_TwoParameters_String )              
widget.show() 

发射信号

通过emit方法发射信号。

class MyWidget(QWidget):  

    def mousePressEvent(self, event):  
        # 发射无参数的信号
        self.Signal_NoParameters.emit() 
        # 发射带一个参数(整数)的信号
        self.Signal_OneParameter.emit(1) 
        # 发射带一个参数(整数)的重载版本的信号
        self.Signal_OneParameter_Overload.emit(1)
        # 发射带一个参数(字符串)的重载版本的信号
        self.Signal_OneParameter_Overload.emit("abc")
        # 发射带两个参数(整数,字符串)的信号
        self.Signal_TwoParameters.emit(1,"abc")
        # 发射带两个参数(整数,整数)的重载版本的信号
        self.Signal_TwoParameters_Overload.emit(1,2)
        # 发射带两个参数(整数,字符串)的重载版本的信号
        self.Signal_TwoParameters_Overload.emit (1,"abc") 

实例演示

from PyQt5.QtCore import QObject , pyqtSignal

class CustSignal(QObject):

    # 声明一个无参数的信号
    signal1 = pyqtSignal()

    # 声明带一个int类型参数的信号
    signal2 = pyqtSignal(int)

    # 声明带一个int和str类型参数的信号
    signal3 = pyqtSignal(int,str)

    # 声明带一个列表类型参数的信号
    signal4 = pyqtSignal(list)

    # 声明带一个字典类型参数的信号
    signal5 = pyqtSignal(dict)

    # 声明一个多重载版本的信号，包括了一个带int和str类型参数的信号或着带str参数的信号
    signal6 = pyqtSignal([int,str], [str])

    def __init__(self,parent=None):
        super(CustSignal,self).__init__(parent)

        # 信号连接到指定槽
        self.signal1.connect(self.signalCall1)
        self.signal2.connect(self.signalCall2)
        self.signal3.connect(self.signalCall3)
        self.signal4.connect(self.signalCall4)
        self.signal5.connect(self.signalCall5)
        self.signal6[int,str].connect(self.signalCall6)
        self.signal6[str].connect(self.signalCall6OverLoad)

        # 信号发射
        self.signal1.emit()
        self.signal2.emit(1)
        self.signal3.emit(1,"text")
        self.signal4.emit([1,2,3,4])
        self.signal5.emit({"name":"wangwu","age":"25"})
        self.signal6[int,str].emit(1,"text")
        self.signal6[str].emit("text")

    def signalCall1(self):
        print("signal1 emit")

    def signalCall2(self,val):
        print("signal2 emit,value:",val)

    def signalCall3(self,val,text):
        print("signal3 emit,value:",val,text)

    def signalCall4(self,val):
        print("signal4 emit,value:",val)

    def signalCall5(self,val):
        print("signal5 emit,value:",val)

    def signalCall6(self,val,text):
        print("signal6 emit,value:",val,text)

    def signalCall6OverLoad(self,val):
        print("signal6 overload emit,value:",val)

if __name__ == '__main__':  
    custSignal = CustSignal()

运行结果：