PyQt5：PyQt5 信號與槽（PyQt5的事件處理機制）

一、事件

　　在事件模型，有三個參與者：事件源、事件目標、事件對象。

• 　　事件源：狀態發生改變的對象，它產生事件 Source_Obj
• 　　事件目標：是想要被通知的對象 Target_Obj
• 　　事件對象：封裝了事件源中的狀態變化 Evnet_Obj

　　PyQt5有一個獨一無二的信號和槽機制來處理事件。信號和槽用於對象之間的通信。當指定事件發生，一個事件信號會被發射。槽可以被任何Python腳本調用。當和槽連接的信號被發射時，槽會被調用。調用示意圖如圖1所示：

圖1

 二、信號和槽（或槽函數）

　　在Qt中，每一個QObject對象和PyQt中所有繼承自QWidget的控件（這些都是QObject的子對象）都支持信號與槽機制。當信號發射時，連接的槽函數將會自動執行。在PyQt 5中信號與槽通過object.signal.connect()方法連接。

　　PyQt的窗口控件類中有很多內置信號，開發者也可以添加自定義信號。信號與槽具有如下特點。

• 一個信號可以連接多個槽。
• 一個信號可以連接另一個信號。
• 信號參數可以是任何Python類型。
• 一個槽可以監聽多個信號。
• 信號與槽的連接方式可以是同步連接，也可以是異步連接。
• 信號與槽的連接可能會跨線程。
• 信號可能會斷開。

　　在GUI編程中，當改變一個控件的狀態時（如單擊了按鈕），通常需要通知另一個控件，也就是實現了對象之間的通信。在早期的GUI編程中使用的是回調機制，在Qt中則使用一種新機制——信號與槽。在編寫一個類時，要先定義該類的信號與槽，在類中信號與槽進行連接，實現對象之間的數據傳輸。信號與槽機制示意圖如圖1所示。

圖2

　　當事件或者狀態發生改變時，就會發出信號。同時，信號會觸發所有與這個事件（信號）相關的函數（槽）。信號與槽可以是多對多的關系。一個信號可以連接多個槽，一個槽也可以監聽多個信號。

　　關於PyQt API中信號與槽的更詳細解釋，可以參考官方網站： http://pyqt.sourceforge.net/Docs/PyQt5/signals_slots.html？highlight=pyqtsignal#PyQt5.QtCore.pyqtSignal。

三、高級自定義信號與槽

　　所謂高級自定義信號與槽，指的是我們可以以自己喜歡的方式定義信號與槽函數，並傳遞參數。自定義信號的一般流程如下：

　　（1）定義信號。

　　（2）定義槽函數。

　　（3）連接信號與槽函數。

　　（4）發射信號。

（1）定義信號

　　通過類成員變量定義信號對象。使用 pyqtSignal()方法

import sys
import PyQt5.QtWidgets as PQW
import PyQt5.QtCore as PQC

class MyWidget(PQW.QWidget):
    # 無參數的信號
    Signal_NoParameters = PQC.pyqtSignal()
    # 帶一個參數(整數)的信號
    Signal_OneParameter = PQC.pyqtSignal(int)
    # 帶一個參數(整數或者字符串)的重載版本的信號
    Signal_OneParameter_Overload = PQC.pyqtSignal([int],[str])
    # 帶兩個參數(整數,字符串)的信號
    Signal_TwoParameters = PQC.pyqtSignal(int,str)
    # 帶兩個參數([整數,整數]或者[整數,字符串])的重載版本的信號
    Signal_TwoParameters_Overload = PQC.pyqtSignal([int,int],[int,str])

（2）定義槽函數

　　定義一個槽函數，它有多個不同的輸入參數。槽函數就是普通類中的函數或方法。

class MyWidget(PQW.QWidget):  #接上例程序，同一個類MyWidget。
    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

 

（3）連接信號與槽函數

　　通過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()  

 

（4）發射信號

　　通過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") 

 

（5）實例

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()

 

運行結果如下：

signal1 emit
signal2 emit,value: 1
signal3 emit,value: 1 text
signal4 emit,value: [1, 2, 3, 4]
signal5 emit,value: {'name': 'wangwu', 'age': '25'}
signal6 emit,value: 1 text
signal6 overload emit,value: text

 四、使用自定義參數

　　在PyQt編程過程中，經常會遇到給槽函數傳遞自定義參數的情況，比如有一個信號與槽函數的連接是：

button1.clicked.connect(show_page)

　　我們知道對於clicked信號來說，它是沒有參數的；對於show_page函數來說，希望它可以接收參數。希望show_page函數像如下這樣：

def show_page(self, name):
    print(name,"  點擊啦")

 　　於是就產生一個問題——信號發出的參數個數為0，槽函數接收的參數個數為1，由於0<1，這樣運行起來一定會報錯（原因是信號發出的參數個數一定要大於槽函數接收的參數個數）。解決這個問題就是：自定義參數的傳遞。

　　有兩種解決方法，其中一種解決方法是使用lambda表達式。其完整代碼如下：

from PyQt5.QtWidgets import QMainWindow, QPushButton , QWidget , QMessageBox, QApplication, QHBoxLayout
import sys

class WinForm(QMainWindow):
    def __init__(self, parent=None):
        super(WinForm, self).__init__(parent)
        button1 = QPushButton('Button 1')
        button2 = QPushButton('Button 2')

        button1.clicked.connect(lambda: self.onButtonClick(1))
        button2.clicked.connect(lambda: self.onButtonClick(2))

        layout = QHBoxLayout()
        layout.addWidget(button1)
        layout.addWidget(button2)

        main_frame = QWidget()
        main_frame.setLayout(layout)
        self.setCentralWidget(main_frame)

    def onButtonClick(self, n):
        print('Button {0} 被按下了'.format(n))
        QMessageBox.information(self, "信息提示框", 'Button {0} clicked'.format(n))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = WinForm()
    form.setGeometry(300,300,600,400)
    form.show()
    sys.exit(app.exec_())

 運行效果如下：

圖3

　　這里重點解釋onButtonClick()函數是怎樣處理從兩個按鈕傳來的信號的。使用lambda表達式傳遞按鈕數字給槽函數，當然也可以傳遞其他任何東西，甚至是按鈕控件本身（假設槽函數打算把傳遞信號的按鈕修改為不可用的話）。

　　另一種解決方法是使用functools中的partial函數。實例代碼如下：

from PyQt5.QtWidgets import QMainWindow, QPushButton , QWidget , QMessageBox, QApplication, QHBoxLayout
import sys
from functools import partial

class WinForm(QMainWindow):
    def __init__(self, parent=None):
        super(WinForm, self).__init__(parent)
        button1 = QPushButton('Button 1')
        button2 = QPushButton('Button 2')

        # button1.clicked.connect(lambda: self.onButtonClick(1))
        # button2.clicked.connect(lambda: self.onButtonClick(2))
        button1.clicked.connect(partial(self.onButtonClick, 1))
        button2.clicked.connect(partial(self.onButtonClick, 2))

        layout = QHBoxLayout()
        layout.addWidget(button1)
        layout.addWidget(button2)

        main_frame = QWidget()
        main_frame.setLayout(layout)
        self.setCentralWidget(main_frame)

    def onButtonClick(self, n):
        print('Button {0} 被按下了'.format(n))
        QMessageBox.information(self, "信息提示框", 'Button {0} clicked'.format(n))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = WinForm()
    form.setGeometry(300,300,600,400)
    form.show()
    sys.exit(app.exec_())

 　　運行效果和上圖一樣。采用哪種方法好一點呢？這屬於風格問題，筆者比較喜歡使用lambda表達式，因為其條理清晰，而且靈活。

五、裝飾器信號與槽

　　所謂裝飾器信號與槽，就是通過裝飾器的方法來定義信號和槽函數。具體的使用方法如下：

@PyQt5.QtCore.pyqtSlot(參數)
def on_發送者對象名稱_發射信號名稱(self, 參數):
        pass

　　這種方法有效的前提是下面的函數已經被執行：

QtCore.QMetaObject.connectSlotsByName(QObject)

 

 　　在上面代碼中，“發送者對象名稱”就是使用setObjectName函數設置的名稱，因此自定義槽函數的命名規則也可以看成：on + 使用setObjectName設置的名稱 + 信號名稱。接下來看具體的使用方法，完整代碼如下：

from PyQt5 import QtCore
from PyQt5.QtWidgets import QApplication  ,QWidget ,QHBoxLayout , QPushButton
import sys

class CustWidget(QWidget):

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

        self.okButton = QPushButton("OK", self)
        #使用setObjectName設置對象名稱
        self.okButton.setObjectName("okButton")
        layout = QHBoxLayout()
        layout.addWidget(self.okButton)
        self.setLayout(layout)
        QtCore.QMetaObject.connectSlotsByName(self)

    @QtCore.pyqtSlot()
    def on_okButton_clicked(self):
        print( "單擊了OK按鈕")

if __name__ == "__main__":
    app =  QApplication(sys.argv)
    win = CustWidget()
    win.setWindowTitle('裝飾器信號和槽')
    win.setGeometry(300,300,600,400)
    win.show()
    app.exec_()

 　　運行腳本，顯示效果如圖所示。單擊“OK”按鈕，控制台打印出預期的調試信息。

圖4

 　　有的讀者可能注意到，我們一直沒有解釋下面這行代碼的含義：QtCore.QMetaObject.connectSlotsByName(QObject)，事實上，它是在PyQt 5中根據信號名稱自動連接到槽函數的核心代碼。通過前面章節中的例子可以知道，使用pyuic5命令生成的代碼中會帶有這么一行代碼，接下來對其進行解釋。

　　這行代碼用來將QObject中的子孫對象的某些信號按照其objectName連接到相應的槽函數。這句話讀起來有些拗口，這里舉個例子進行簡單說明。以上面例子中的代碼為例：

　　假設代碼QtCore.QMetaObject.connectSlotsByName(self)已經執行，則下面的代碼：

@QtCore.pyqtSlot()    
def on_okButton_clicked(self):
    print( "單擊了OK按鈕")

 

　　會被自動識別為下面的代碼（注意，函數中去掉了on，因為on會受到connectSlotsByName的影響，加上on運行時會出現問題）：

def __init__(self, parent=None):

    self.okButton.clicked.connect(self.okButton_clicked)

    def okButton_clicked(self):
        print("單擊了OK按鈕")

 實例如下：

from PyQt5 import QtCore 
from PyQt5.QtWidgets import QApplication ,QWidget ,QHBoxLayout , QPushButton
import sys

class CustWidget( QWidget ):

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

        self.okButton = QPushButton("OK", self)
        #使用setObjectName設置對象名稱
        self.okButton.setObjectName("okButton")
        layout =  QHBoxLayout()
        layout.addWidget(self.okButton)
        self.setLayout(layout)
        QtCore.QMetaObject.connectSlotsByName(self)
        self.okButton.clicked.connect(self.okButton_clicked)

    def okButton_clicked(self):
        print( "單擊了OK按鈕")

if __name__ == "__main__":
    app =  QApplication(sys.argv)
    win = CustWidget()
    win.show()
    sys.exit(app.exec_())

運行上述代碼，結果和圖4一樣。

六、信號與槽的斷開和連接

　　有時候基於某些原因，想要臨時或永久斷開某個信號與槽的連接。這就是本節案例想要達到的目的。其完整代碼如下：

from PyQt5.QtCore import QObject , pyqtSignal

class SignalClass(QObject):

     # 聲明無參數的信號
    signal1 = pyqtSignal()

    # 聲明帶一個int類型參數的信號
    signal2 = pyqtSignal(int)

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

        # 將信號signal1連接到sin1Call和sin2Call這兩個槽函數
        self.signal1.connect(self.sin1Call)
        self.signal1.connect(self.sin2Call)

        # 將信號signal2連接到信號signal1
        self.signal2.connect(self.signal1)

        # 發射信號
        self.signal1.emit()
        self.signal2.emit(1)

        # 斷開signal1、signal2信號與各槽函數的連接
        self.signal1.disconnect(self.sin1Call)
        self.signal1.disconnect(self.sin2Call)
        self.signal2.disconnect(self.signal1)

        # 將信號signal1和signal2連接到同一個槽函數sin1Call
        self.signal1.connect(self.sin1Call)
        self.signal2.connect(self.sin1Call)

        # 再次發射信號
        self.signal1.emit()
        self.signal2.emit(1)

    def sin1Call(self):
        print("signal-1 emit")

    def sin2Call(self):
        print("signal-2 emit")

if __name__ == '__main__':
    signal = SignalClass()

  運行結果如下：

signal-1 emit
signal-2 emit
signal-1 emit
signal-2 emit
signal-1 emit
signal-1 emit

七、多線程中信號與槽的使用

1、簡單多線程中信號與槽的使用 　　

　　最簡單的多線程使用方法是利用QThread函數，如下代碼展示了QThread函數和信號與槽簡單的結合方法。其完整代碼如下： 

# 多線程中信號與槽的使用
from PyQt5.QtWidgets import  QApplication ,QWidget
from PyQt5.QtCore import QThread ,  pyqtSignal
import sys

class Main(QWidget):
    def __init__(self, parent = None):
        super(Main,self).__init__(parent)

        # 創建一個線程實例並設置名稱、變量、信號與槽
        self.thread = MyThread()        
        self.thread.setIdentity("thread1")
        self.thread.sinOut.connect(self.outText)
        self.thread.setVal(6)

    def outText(self,text):
        print(text)

class MyThread(QThread):
    sinOut = pyqtSignal(str)

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

    def setIdentity(self,text):
        self.identity = text

    def setVal(self,val):
        self.times = int(val)
        # 執行線程的run方法
        self.start()

    def run(self):
        while self.times > 0 and self.identity:
            # 發射信號
            self.sinOut.emit(self.identity+"==>"+str(self.times))
            self.times -= 1

if __name__ == '__main__':
    app = QApplication(sys.argv)
    main = Main()
    main.show()
    sys.exit(app.exec_())

 

運行結果：

thread1==>6
thread1==>5
thread1==>4
thread1==>3
thread1==>2
thread1==>1

 

2、多線程處理顯示和邏輯運算分開

　　有時在開發程序時經常會執行一些耗時的操作，這樣就會導致界面卡頓，這也是多線程的應用范圍之一——為了解決這個問題，我們可以創建多線程，使用主線程更新界面，使用子線程實時處理數據，最后將結果顯示到界面上。

　　下例中，定義了一個后台線程類BackendThread來模擬后台耗時操作，在這個線程類中定義了信號update_date。使用BackendThread線程類在后台處理數據，每秒發射一次自定義信號update_date。

　　在初始化窗口界面時，定義后台線程類BackendThread，並把線程類的信號update_date連接到槽函數handleDisplay()。這樣后台線程每發射一次信號，就可以把最新的時間值實時顯示在前台窗口的QLineEdit文本對話框中，完整示例代碼如下：

from PyQt5.QtCore import QThread ,  pyqtSignal,  QDateTime
from PyQt5.QtWidgets import QApplication,  QDialog,  QLineEdit
import time
import sys

class BackendThread(QThread):    # 該類模擬后台
    # 通過類成員對象定義信號
    update_date = pyqtSignal(str)

    # 處理業務邏輯
    def run(self):
        while True:
            data = QDateTime.currentDateTime()
            currTime = data.toString("yyyy-MM-dd hh:mm:ss")
            self.update_date.emit(str(currTime))   #通過sleep(1),每秒發射一個信號
            time.sleep(1)

# class Window(QDialog):  #界面類，用於顯示
class Window(PQW.QWidget):
    def __init__(self):
        # QDialog.__init__(self)
        super().__init__()
        self.setWindowTitle('PyQt 5界面實時更新例子')
        self.resize(400, 100)
        self.input = QLineEdit(self)
        self.input.resize(400, 30)
        self.initUI()

    def initUI(self):
        # 創建線程
        self.backend = BackendThread()
        # 連接信號
        self.backend.update_date.connect(self.handleDisplay)
        # 開始線程
        self.backend.start()

    # 將當前時間輸出到文本框
    def handleDisplay(self, data):
        self.input.setText(data)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = Window()
    win.show()
    sys.exit(app.exec_())

 運行結果：

 

 

圖5

參考博文：https://blog.csdn.net/broadview2006/article/details/78475842