訊號（Signal）和槽（Slot）是Qt中的核心機制，也是在PyQt程式設計中物件之間進行通訊的機制。本文介紹了幾種PyQt 5訊號與槽的幾級玩法。

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

PyQt的視窗控制元件類中有很多內建訊號，開發者也可以新增自定義訊號。訊號與槽具有如下特點。

• 一個訊號可以連線多個槽。
• 一個訊號可以連線另一個訊號。
• 訊號引數可以是任何Python型別。
• 一個槽可以監聽多個訊號。
• 訊號與槽的連線方式可以是同步連線，也可以是非同步連線。
• 訊號與槽的連線可能會跨執行緒。
• 訊號可能會斷開。

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

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

關於PyQt API中訊號與槽的更詳細解釋，可以參考官方網站： http://pyqt.sourceforge.net/Docs/PyQt5/signals_slots.html

1 高階自定義訊號與槽

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

（1）定義訊號。

（2）定義槽函式。

（3）連線訊號與槽函式。

（4）發射訊號。

1．定義訊號

通過類成員變數定義訊號物件。

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

2．定義槽函式

定義一個槽函式，它有多個不同的輸入引數。

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,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．例項

本例檔名為PyQt5/Chapter07/qt07_signalSlot02.py，其完整程式碼如下：

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,text)

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

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

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

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

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

執行結果如下：

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

2 使用自定義引數

在PyQt程式設計過程中，經常會遇到給槽函式傳遞自定義引數的情況，比如有一個訊號與槽函式的連線是

button1.clicked.connect(show_page)

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

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

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

本書提供了兩種解決方法，其中一種解決方法是使用lambda表示式。本例檔名為PyQt5/Chapter07/qt07_ winSignalSlot04.py ，其完整程式碼如下：

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.show() 
  sys.exit(app.exec_())

執行指令碼，顯示效果如圖2和圖3所示。

程式碼分析：

單擊“Button 1”按鈕，將彈出一個資訊提示框，提示資訊為“Button 1 clicked”。Python控制檯的輸出資訊為：

Button 1 被按下了

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

另一種解決方法是使用functools中的partial函式。本例檔名為PyQt5/Chapter07/qt07_winSignalSlot05.py，其核心程式碼如下：

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

採用哪種方法好一點呢？這屬於風格問題，筆者比較喜歡使用lambda表示式，因為其條理清晰，而且靈活。

3 裝飾器訊號與槽

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

@PyQt5.QtCore.pyqtSlot(引數)
def on_傳送者物件名稱_發射訊號名稱(self,引數):
    pass

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

QMetaObject.connectSlotsByName(QObject)

在上面程式碼中，“傳送者物件名稱”就是使用setObjectName函式設定的名稱，因此自定義槽函式的命名規則也可以看成：on + 使用setObjectName設定的名稱 + 訊號名稱。接下來看具體的使用方法。

本例檔名為PyQt5/Chapter07/qt07_connSlotsByName.py，其完整程式碼如下：

from PyQt5 import QtCore 
from PyQt5.QtWidgets import QApplication,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.show()
  app.exec_()

執行指令碼，顯示效果如圖4所示。單擊“OK”按鈕，控制檯打印出預期的除錯資訊。

有的讀者可能注意到，我們一直沒有解釋下面這行程式碼的含義：

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按鈕")

這部分程式碼放在PyQt5/Chapter07/qt07_connSlotsByName_2.py檔案中：

# -*- coding: utf-8 -*-

"""
  【簡介】
  訊號與槽的自動連線例子
"""

from PyQt5 import QtCore 
from PyQt5.QtWidgets import QApplication,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一樣。

4 訊號與槽的斷開和連線

有時候基於某些原因，想要臨時或永久斷開某個訊號與槽的連線。這就是本節案例想要達到的目的。

本例檔名為PyQt5/Chapter07/qt07_signalSlot03.py，其完整程式碼如下：

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

5 多執行緒中訊號與槽的使用

最簡單的多執行緒使用方法是利用QThread函式，如下程式碼（見PyQt5/Chapter07/ qt07_signalSlot04.py）展示了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

有時在開發程式時經常會執行一些耗時的操作，這樣就會導致介面卡頓，這也是多執行緒的應用範圍之一——為了解決這個問題，我們可以建立多執行緒，使用主執行緒更新介面，使用子執行緒實時處理資料，最後將結果顯示到介面上。

本例中，定義了一個後臺執行緒類BackendThread來模擬後臺耗時操作，在這個執行緒類中定義了訊號update_date。使用BackendThread執行緒類在後臺處理資料，每秒發射一次自定義訊號update_date。

在初始化視窗介面時，定義後臺執行緒類BackendThread，並把執行緒類的訊號update_date連線到槽函式handleDisplay()。這樣後臺執行緒每發射一次訊號，就可以把最新的時間值實時顯示在前臺視窗的QLineEdit文字對話方塊中。

本例檔名為PyQt5/Chapter07/qt07_signalSlotThreaad.py，其完整程式碼如下：

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) )
      time.sleep(1)

class Window(QDialog):
  def __init__(self):
    QDialog.__init__(self)
    self.setWindowTitle('PyQt 5介面實時更新例子')
    self.resize(400,100)
    self.input = QLineEdit(self)
    self.input.resize(400,100)
    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所示。

到此這篇關於詳解PyQt5訊號與槽的幾種高階玩法的文章就介紹到這了,更多相關PyQt5訊號與槽內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！