PySimpleGUI - 快速指南

---

---

PySimpleGUI - 簡介

適合人類的 Python GUI

PySimpleGUI 專案最初是作為 TKinter 包的包裝器而啟動的，TKinter 包與 Python 的標準庫捆綁在一起，目的是簡化 GUI 構建過程。

PySimpleGUI 隨後增加了基於 PySide 庫（它本身將最初用 C++ 編寫的 Qt GUI 工具包移植到 Python）和 WxPython（它移植另一個流行的 GUI 工具包 WxWidgets）設計桌面 GUI 的能力。這些庫分別稱為PySimpleGUIQt 和PySimpleGUIWx。

PySimpleGui 系列的最新成員是PySimpleGUIWeb 包，它使用 Remi（REMote Interface Library）構建在網頁中呈現的 GUI 設計。

PySimpleGui 組中的所有包都遵循類似的 API，這意味著 GUI 元素的名稱、它們的屬性和方法在所有四個包中都相同。因此，只需替換 import 語句（並保持程式碼的其餘部分不變），就可以獲得相應的 GUI 設計呈現。這實際上是 PySimpleGui 最重要的功能。因此，它被稱為適合人類的 Python GUI。

與其他 GUI 框架的比較

Python 程式設計師有多種 GUI 框架可供選擇，以開發 GUI 應用程式。TKinter 是 Python 標準庫中正式包含的一個。其他大多數是開源的，必須顯式安裝。

PySimpleGUI - 環境設定

PySimpleGUI 支援 Python 3.x 版本以及 Python 2.7 版本。主埠 PySimpleGUI 沒有任何外部依賴項，因為它是基於 Tkinter 的，而 Tkinter 是 Python 標準庫的一部分，因此無需單獨安裝。使用 PIP 安裝程式在當前 Python3 環境中安裝它，如下所示

pip3 install PySimpleGUI

要驗證庫是否正確安裝，請輸入以下語句：

>>> import PySimpleGUI
>>> PySimpleGUI.version
'4.60.1 Released 22-May-2022'

如果 PIP 安裝不起作用，您可以從 Github 儲存庫 (https://github.com/PySimpleGUI/PySimpleGUI)下載 "pysimplegui.py" 並將其放在您的資料夾中，以及匯入它的應用程式。

pysimplegui.py 檔案具有 "main()" 函式。當從 Python 提示符呼叫時，它會生成以下視窗以確認包已正確安裝。

>>> import PySimpleGUI as psg
>>> psg.main()
Starting up PySimpleGUI Diagnostic & Help System
PySimpleGUI long version = 4.60.1 Released 22-May-2022
PySimpleGUI Version 4.60.1
tcl ver = 8.6 tkinter version = 8.6
Python Version 3.6.8 (tags/v3.6.8:3c6b436a57, Dec 24 2018,
00:16:47) [MSC v.1916 64 bit (AMD64)]
tcl detailed version = 8.6.6
PySimpleGUI.py location F:\python36\lib\sitepackages\PySimpleGUI\PySimpleGUI.py

GUI 視窗如下所示

如果您使用的是早於 3.4 的 Python3 版本，則可能需要安裝 "typing" 模組，因為它未包含在相應的標準庫中。

pip3 install typing

對於 Python 2.7，將名稱更改為 PySimpleGUI27。

pip3 install PySimpleGUI27

對於 2.7 版本，您可能還需要安裝 "future"。

pip3 install future

但是，需要注意的是，Python 軟體基金會不正式支援 Python 2.x 分支。

PySimpleGUI - Hello World

使用 PySimpleGUI 建立第一個視窗

要檢查 PySimpleGUI 及其依賴項是否已正確安裝，請輸入以下程式碼並將其儲存為 "hello.py"，使用任何 Python 感知編輯器。

import PySimpleGUI as psg
layout = [[psg.Text(text='Hello World',
   font=('Arial Bold', 20),
   size=20,
   expand_x=True,
   justification='center')],
]
window = psg.Window('HelloWorld', layout, size=(715,250))
while True:
   event, values = window.read()
   print(event, values)
   if event in (None, 'Exit'):
      break
window.close()

以上程式碼構建了一個帶有 Text 元素（相當於 TKinter 中的 Label）的視窗，並在視窗的整個寬度上居中顯示“Hello World”訊息。

從命令終端執行此程式，如下所示：

Python hello.py

程式生成的輸出應類似於以下顯示的內容：

等效的 Tkinter 程式碼

要使用純 Tkinter 程式碼獲得類似的輸出，我們需要以下 Python 指令碼：

from tkinter import *
window=Tk()
lbl=Label(window, text="Hello World",
   fg='white', bg='#64778D',
   font=("Arial Bold", 20))
lbl.place(x=300, y=15)
window.title('HelloWorld Tk')
window['bg']='#64778D'
window.geometry("715x250+10+10")
window.mainloop()

所有其他功能保持不變，除了我們使用waitress模組的serve()函式啟動 WSGI 伺服器。在執行程式後訪問瀏覽器中的“/”路由，將顯示“Hello World”訊息，如前所述。

除了函式之外，可呼叫類也可以用作 View。可呼叫類是覆蓋了__call__()方法的類。

from pyramid.response import Response
class MyView(object):
   def __init__(self, request):
      self.request = request
   def __call__(self):
      return Response('hello world')

PySimpleGUIQt

PySimpleGUI API 的物件模型已與 PySide2 包（它是 Qt 圖形工具包的 Python 埠）中定義的小部件相容。Qt 版本的 PySimpleGui 稱為 PySimpleGUIQt。可以使用以下 PIP 命令類似地安裝它：

pip3 install PySimpleGUIQt

由於此包依賴於 PySide2，因此也會安裝 PySide2。

>>> import PySide2
>>> PySide2.__version__
'5.15.2.1'
>>> import PySimpleGUIQt
>>> PySimpleGUIQt.version
'0.35.0 Released 6-Jun-2020'

如前所述，PySimpleGui 專案最重要的功能是為一個包編寫的程式碼與其他包完全相容。因此，前面使用的 hello.py 程式可以按原樣用於 Qt 版本。唯一需要的更改是匯入 PySimpleGUIQt 而不是 PySimpleGui。

import PySimpleGUIQt as psg
layout = [[psg.Text(text='Hello World',
   font=('Arial Bold', 20),
   justification='center')],
]
window = psg.Window('HelloWorldQt', layout, size=(715,250))
while True:
   event, values = window.read()
   print(event, values)
   if event in (None, 'Exit'):
      break
window.close()

輸出非常相似。

等效的 PySide2 程式碼

實現相同結果的純 PySide2 程式碼如下：

import sys
from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import *
def window():
   app = QApplication(sys.argv)
   w = QWidget()
   w.setStyleSheet("background-color: #64778D;")

   b = QLabel(w)
   b.setText("Hello World!")
   b.setFont(QFont('Arial Bold', 20))
   b.setAlignment(Qt.AlignCenter)
   b.setStyleSheet("color: white;")
   b.setGeometry(100, 100, 715, 250)
   b.move(50, 20)

   w.setWindowTitle("HelloWorldQt")
   w.show()
   sys.exit(app.exec_())
   if __name__ == '__main__':
      window()

它將生成相同的輸出視窗。

PySimpleGUIWx

此模組封裝了在 WxPython 工具包中定義的 GUI 小部件的功能。WxPython 是最初用 C++ 編寫的廣泛使用的 WxWidgets 庫的 Python 埠。顯然，PySimpleGUIWx 依賴於 WxPython 包，因此後者將透過以下 PIP 命令自動安裝：

pip3 install PySimpleGUIWx

要確認 PySimpleGUIWx 和 WxPython 是否已正確安裝，請在 Python 終端中輸入以下語句。

>>> import PySimpleGUIWx
>>> PySimpleGUIWx.version
'0.17.1 Released 7-Jun-2020'
>>> import wx
>>> wx.__version__
'4.0.7'

"hello.py" 指令碼不需要做太多更改。我們只需要在 "import" 語句中用 PySimpleGUIWx 模組替換 PySimpleGUI。

import PySimpleGUIWx as psg
layout = [[psg.Text(text='Hello World',
   font=('Arial Bold', 20),
   size=(500, 5),
   justification='center')],
]
window = psg.Window('HelloWorldWx', layout, size=(715, 250))
while True:
   event, values = window.read()
   print(event, values)
   if event in (None, 'Exit'):
      break
window.close()

它將產生以下輸出

請注意，您需要使用稍微複雜的程式碼才能獲得類似的純 WxPython 程式碼輸出，如下所示：

import wx
app = wx.App()
window = wx.Frame(None, title="WxPython", size=(715, 250))
panel = wx.Panel(window)
panel.SetBackgroundColour((100, 119, 141))
label = wx.StaticText(panel, -1, style=wx.ALIGN_CENTER)
label.SetLabel("Hello World")
label.SetForegroundColour((255, 255, 255))
font = wx.Font()
font.SetFaceName("Arial Bold")
font.SetPointSize(30)
label.SetFont(font)
window.Show(True)
app.MainLoop()

它將顯示一個頂級視窗，其中包含一個文字標籤，其標題為“Hello World”。

PySimpleGUIWeb

Remi（REMote Interface）是一個用於在 Web 瀏覽器中呈現的 Python 應用程式的 GUI 庫。PySimpleGUIWeb 包將原始 PySimpleGui 庫移植到 Remi，以便其應用程式可以在瀏覽器中執行。以下 PIP 命令在當前 Python 環境中安裝 PySimpleGUIWeb 和 Remi：

pip3 install PySimpleGUIWeb

在編寫應用程式之前，請檢查它們是否已正確安裝。

>>> import PySimpleGUIWeb
>>> PySimpleGUIWeb.version
'0.39.0 Released 6-Jun-2020'

以下指令碼是原始 Hello World 程式的 PySimpleGUIWeb 版本。

import PySimpleGUIWeb as psg
layout = [[psg.Text(text='Hello World',
   font=('Arial Bold', 20),
   justification='center')]]
window = psg.Window('HelloWorldWeb', layout)
while True:
   event, values = window.read()
   print(event, values)
   if event in (None, 'Exit'):
      break
window.close()

要使用純 Remi 庫的功能獲得類似的輸出，稍微複雜一些，如下面的程式碼所示

import remi.gui as gui
from remi import start, App
class HelloWeb(App):
   def __init__(self, *args):
      super(HelloWeb, self).__init__(*args)
   def main(self):
      wid = gui.VBox(style={"background-color": "#64778D"})
      self.lbl = gui.Label('Hello World', width='100%', height='100%',
      style={ "color":"white",
         "text-align": "center",
         "font-family": "Arial Bold",
         "font-size": "20px"}
      )
      wid.append(self.lbl)
      return wid
      if __name__ == "__main__":
         start(HelloWeb, debug=True, address='0.0.0.0', port=0)

當我們執行這些程式時，Remi 伺服器啟動，瀏覽器視窗自動開啟並顯示“Hello World”訊息。

在這裡，我們看到了用 PySimpleGUI、PySimpleGUIQt、PySimpleGUIWx 和 PySimpleGUIWeb 庫編寫的 Hello World 程式。我們可以看到，小部件庫保持不變。此外，當分別用純 Tkinter、PySide、WxPython 和 Remi 編寫相同的 Hello World 程式時，它變得比 PySimpleGUI 版本複雜和繁瑣得多。

PySimpleGUI - 彈出視窗

PySimpleGUI 模組中以 "popup*" 為字首的函式會生成具有預定義外觀的視窗。彈出函式的名稱指示其用途和其上存在的按鈕的配置。這些彈出視窗只需一行程式碼即可建立。每個彈出視窗都具有一定的用途，然後立即關閉。

最基本的彈出視窗由popup()函式建立。它可以像 print() 函式一樣使用，在視窗上顯示多個引數，以及一個“確定”按鈕。它充當訊息框，在按下“確定”按鈕後立即消失。

>>> import PySimpleGUI as psg
>>> psg.popup("Hello World")

它顯示一個帶有“Hello World”文字和“確定”按鈕的彈出視窗。請注意，可以顯示多個字串。以下彈出視窗具有不同的按鈕配置：

• popup_ok - 僅顯示帶有“確定”按鈕的彈出視窗

• popup_ok_cancel - 顯示帶有“確定”和“取消”按鈕的彈出視窗

• popup_cancel - 顯示帶有“已取消”按鈕文字的彈出視窗

• popup_yes_no - 顯示帶有“是”和“否”按鈕的彈出視窗

• popup_error - 帶有彩色按鈕且按鈕文字為“錯誤”的彈出視窗

這些函式返回使用者按下的按鈕的文字。例如，如果使用者按下確定取消彈出視窗的“確定”按鈕，它將返回“確定”，該值可用於進一步的程式設計邏輯。

以下彈出視窗以文字的形式接受使用者的輸入，或讓使用者從選擇器中選擇檔案/資料夾/日期。

• popup_get_text - 顯示帶有文字輸入欄位的彈出視窗。返回輸入的文字，如果關閉/取消則返回 None

• popup_get_file - 顯示帶有文字輸入欄位和瀏覽按鈕的彈出視窗，以便使用者可以選擇檔案。

• popup_get_folder - 顯示帶有文字輸入欄位和瀏覽按鈕的彈出視窗，以便使用者可以選擇資料夾。

• popup_get_date - 顯示日曆視窗，獲取使用者的選擇，返回元組 (月，日，年)

當用戶做出選擇並按下“確定”按鈕時，彈出視窗的返回值是文字，該文字可以在程式中進一步使用。

以下指令碼顯示了一些上述彈出視窗的使用：

import PySimpleGUI as psg
text = psg.popup_get_text('Enter your name', title="Textbox")
print ("You entered: ", text)
file=psg.popup_get_file('Select a file',  title="File selector")
print ("File selected", file)
folder=psg.popup_get_folder('Get folder', title="Folder selector")
print ("Folder selected",folder)
ch = psg.popup_yes_no("Do you want to Continue?",  title="YesNo")
print ("You clicked", ch)
ch = psg.popup_ok_cancel("Press Ok to proceed", "Press cancel to stop",  title="OkCancel")
if ch=="OK":
   print ("You pressed OK")
if ch=="Cancel":
   print ("You pressed Cancel")
psg.popup_no_buttons('You pressed', ch, non_blocking=True)
psg.popup_auto_close('This window will Autoclose')

輸出 - 上述程式碼生成的彈出視窗如下所示：

在 Python控制檯上顯示以下輸出：

You entered: Tutorialspoint
File selected F:/python36/hello.png
Folder selected F:/python36/Scripts
You clicked Yes
You pressed Cancel

所有型別的彈出視窗都是從 popup 類繼承的相應類的物件。它們都有一組通用的屬性。這些屬性具有某個預設值，可用於自定義彈出視窗物件的外觀和行為。下表列出了常用引數：

帶捲軸的彈出視窗

popup_scrolled() 函式生成一個帶可滾動文字框的彈出視窗。使用它來顯示大量文字，這些文字包含許多行，字元數超過寬度。

size 屬性是一個元組 (w, h)，其中“w”表示一行中的字元數，“h”表示一次顯示的行數。如果文字的字元數/行數超過“w”或“h”，則文字框的水平/垂直捲軸將變為活動狀態。

在以下示例中，一個大型檔案 zen.txt 在一個帶有可滾動文字框的彈出視窗中顯示。該檔案包含稱為“Python 之禪”的 Python 設計原則。

import PySimpleGUI as psg
file=open("zen.txt")
text=file.read()
psg.popup_scrolled(text, title="Scrolled Popup", font=("Arial Bold", 16), size=(50,10))

它將產生以下輸出 -

進度條

"one_line_progress_meter" 是一個彈出視窗，顯示正在進行的長時間過程（例如迴圈）的視覺化表示。它顯示某個引數的瞬時值、完成過程的估計時間和已用時間。

在以下示例中，逐字元讀取文字檔案。進度條以進度條的形式顯示過程的進度、完成所需的估計時間以及計數的瞬時值。

import PySimpleGUI as psg
import os
size = os.path.getsize('zen.txt')
file=open("zen.txt")
i=0
while True:
   text=file.read(1)
   i=i+1
   if text=="":
      file.close()
      break
   print (text,end='')
   psg.one_line_progress_meter(
      'Progress Meter', i, size,
      'Character Counter'
   )

它將產生以下輸出視窗 -

除錯彈出視窗

在程式執行期間，通常需要跟蹤某些變數的中間值，儘管在以下輸出中不需要。這可以透過 PySimpleGUI 庫中的Print() 函式實現。

注意 - 與 Python 的內建print() 函式不同，此函式中的“P”為大寫。

當程式第一次遇到此函式時，除錯窗口出現，並且所有後續的列印都將在其中回顯。此外，我們可以使用EasyPrint 或eprint，它們也具有相同的效果。

以下程式計算使用者輸入的數字的階乘值。在 for 迴圈中，我們希望跟蹤每次迭代中 f（階乘）的值。這是透過 Print 函式完成的，並在除錯視窗中顯示。

import PySimpleGUI as psg
f=1
num=int(psg.popup_get_text("enter a number: "))
for x in range(1, num+1):
   f=f*x
   psg.Print (f,x)
print ("factorial of {} = {}".format(x,f))

假設使用者輸入 5，則除錯視窗將顯示以下輸出 -

PySimpleGUI - 視窗類

彈出視窗具有預定義的按鈕、文字標籤和文字輸入欄位配置。Window 類允許您設計更靈活的 GUI。除了這些元素之外，還提供了列表框、複選框、單選按鈕等其他元素。您還可以為 GUI 提供菜單系統。某些專門的小部件（如微調器、滑塊等）也可以用於使設計更有效。

視窗可以是非永續性視窗，類似於彈出視窗。它會阻塞程式流程，直到使用者透過單擊客戶端區域上的按鈕或標題欄中的關閉 (X) 按鈕關閉它。

另一方面，永續性視窗會一直可見，直到發生導致其關閉的事件。非同步視窗的內容會定期更新。

佈局結構

視窗客戶端區域中元素或小部件的放置由列表列表物件控制。每個列表元素對應於視窗表面上的一行，並且可能包含 PySimpleGUI 庫中提供的一個或多個 GUI 元素。

第一步是透過繪製如下所示的圖形來視覺化元素的放置 -

視窗上的元素放置在四行中。前三行有一個 Text 元素（顯示靜態文字）和一個 InputText 元素（使用者可以在其中輸入）。最後一行有兩個按鈕，確定和取消。

這在列表列表中表示如下 -

import PySimpleGUI as psg
layout = [
   [psg.Text('Name '),psg.Input()],
   [psg.Text('Address '), psg.Input()],
   [psg.Text('Email ID '), psg.Input()],
   [psg.OK(), psg.Cancel()]
]

此列表物件用作 Window 類建構函式的 layout 引數的值。

window = psg.Window('Form', layout)

這將顯示所需的視窗。使用者輸入儲存在一個名為 values 的字典中。當用戶按下確定按鈕時，將呼叫 Window 類的read() 方法，並且視窗會立即關閉。

呈現視窗的完整程式碼如下 -

import PySimpleGUI as psg
psg.set_options(font=('Arial Bold', 16))
layout = [
   [psg.Text('Name ', size=(15,1)),psg.Input(expand_x=True)],
   [psg.Text('Address ', size=(15,1)), psg.Input(expand_x=True)],
   [psg.Text('Email ID ', size=(15,1)), psg.Input(expand_x=True)],
   [psg.OK(), psg.Cancel()]
]
window = psg.Window('Form', layout, size=(715,207))
event, values = window.read()
print (event, values)
window.close()

以下是顯示的輸出 -

輸入所示資料並按下“確定”按鈕。值將列印如下 -

OK {0: 'Kiran Gupta', 1: 'Mumbai', 2: 'kiran@gmail.com'}

如果在填寫資料後按下“取消”按鈕，則列印的結果將為 -

Cancel {0: 'Kiran Gupta', 1: 'Mumbai', 2: 'kiran@gmail.com'}

永續性視窗

請注意，此視窗在任何按鈕（或標題欄中的“X”按鈕）被單擊時都會立即關閉。要使視窗保持活動狀態，直到按下一種特殊型別的按鈕（稱為退出）或透過按下“X”關閉視窗，read() 方法將放置在一個無限迴圈中，並提供在發生 WIN_CLOSED 事件（當按下退出按鈕時）或 Exit 事件（當按下“X”按鈕時）時中斷的機制。

讓我們將上面程式碼中的取消按鈕更改為退出按鈕。

import PySimpleGUI as psg
layout = [
   [psg.Text('Name '), psg.Input()],
   [psg.Text('Address '), psg.Input()],
   [psg.Text('Email ID '), psg.Input()],
   [psg.OK(), psg.Exit()]
]
window = psg.Window('Form', layout)
while True:
   event, values = window.read()
   if event == psg.WIN_CLOSED or event == 'Exit':
      break
   print (event, values)
window.close()

視窗的外觀將與之前類似，只是取消按鈕變成了退出按鈕。

輸入的資料將以元組的形式列印。第一個元素是事件，即按鈕的標題，第二個是字典，其鍵是遞增的數字，值是輸入的文字。

OK {0: 'kiran', 1: 'Mumbai', 2: 'kiran@gmail.com'}
OK {0: 'kirti', 1: 'Hyderabad', 2: 'kirti@gmail.com'}
OK {0: 'karim', 1: 'Chennai', 2: 'karim@gmail.com'}

視窗方法

Window 類中定義的重要方法是read() 方法，用於收集所有輸入元素中輸入的值。Window 類還有其他方法可以自定義外觀和行為。它們列在下面 -

使用鍵更新視窗

使用者在窗口布局的不同輸入元素中輸入的資料以字典格式儲存。字典鍵編號（從 0 開始），對應於從左到右、從上到下的輸入元素。我們可以透過字典運算子引用輸入資料。這意味著，第一個元素中的資料由“values[0]”返回。

values = {0: 'kiran', 1: 'Mumbai', 2: 'kiran@gmail.com'}
data = [values[k] for k in values.keys()]
print (data)

它將在控制檯上列印以下內容 -

['kiran', 'Mumbai', 'kiran@gmail.com']

但是，如果您想以程式設計方式操作元素的值，則必須透過為其 key 引數分配唯一的字串值來初始化該元素。元素的鍵類似於變數或識別符號的名稱，這使得以程式設計方式處理讀取或為其分配值變得方便。

key 引數應為字串。約定是它應該是一個以“-”字元開頭和結尾的大寫字串（例如：“- NAME-”）。但是，可以使用任何字串。

讓我們在上面的示例中為 Input 元素分配鍵，如下所示 -

layout = [
   [psg.Text('Name '),psg.Input(key='-NM-')],
   [psg.Text('Address '), psg.Input(key='-AD-')],
   [psg.Text('Email ID '), psg.Input(key='-ID-')],
   [psg.OK(), psg.Exit()],
]

結果，read() 方法返回的 values 字典將包含鍵識別符號，而不是之前的整數。

OK {'-NM-': 'Kiran', '-AD-': 'Mumbai', '-ID-': 'kiran@gmail.com'}

現在，values['-NM-'] 將獲取“Kiran”。鍵可以分配給任何元素，而不僅僅是輸入元素。您可以使用相同的鍵呼叫元素上的 Update。我們可以使用 Window 物件的“find_element(key)”，或者使用 window['key'] 來引用該元素。

讓我們擴充套件我們之前的示例，在確定和取消按鈕之前新增一行，並使用“-OUT-”鍵新增一個空的 Text 元素。在 OK 事件中，此 Text 標籤將顯示在具有鍵“-NM-”、“-AD-”和“-ID-”的三個輸入元素中輸入的資料的串聯。

import PySimpleGUI as psg
psg.set_options(font=('Arial Bold', 16))
layout = [
   [psg.Text('Name ', size=(15, 1)),
   psg.Input(key='-NM-', expand_x=True)],
   [psg.Text('Address ', size=(15, 1)),
   psg.Input(key='-AD-', expand_x=True)],
   [psg.Text('Email ID ', size=(15, 1)),
   psg.Input(key='-ID-', expand_x=True)],
   [psg.Text('You Entered '), psg.Text(key='-OUT-')],
   [psg.OK(), psg.Exit()],
]
window = psg.Window('Form', layout, size=(715, 200))
while True:
   event, values = window.read()
   print(event, values)
   out = values['-NM-'] + ' ' + values['-AD-'] + ' ' + values['-ID-']
   window['-OUT-'].update(out)
   if event == psg.WIN_CLOSED or event == 'Exit':
      break
window.close()

執行以上程式碼，在三個輸入元素中輸入文字並按下 OK。-OUT- 文字標籤將更新如下所示 -

另一個使用 key 屬性的示例如下所示。有兩個 Input 元素，分配了鍵引數 -FIRST- 和 -SECOND-。有兩個按鈕，標題為 Add 和 Sub。Text 元素根據按下的按鈕顯示兩個數字的加法或減法。

import PySimpleGUI as psg
import PySimpleGUI as psg
psg.set_options(font=('Arial Bold', 16))
layout = [
   [psg.Text('Enter a num: '), psg.Input(key='-FIRST-')],
   [psg.Text('Enter a num: '), psg.Input(key='-SECOND-')],
   [psg.Text('Result : '), psg.Text(key='-OUT-')],
   [psg.Button("Add"), psg.Button("Sub"), psg.Exit()],
]
window = psg.Window('Calculator', layout, size=(715, 180))
while True:
   event, values = window.read()
   print(event, values)
   if event == "Add":
      result = int(values['-FIRST-']) + int(values['-SECOND-'])
   if event == "Sub":
      result = int(values['-FIRST-']) - int(values['-SECOND-'])
   window['-OUT-'].update(result)
   if event == psg.WIN_CLOSED or event == 'Exit':
      break
window.close()

以下螢幕截圖顯示按下“Add”按鈕時的結果。

無邊框視窗

預設情況下，應用程式視窗是在客戶端區域上方建立一個標題欄，其中所有其他元素都放置在佈局中。標題欄左側包含視窗標題，右側包含控制按鈕（最小化、還原/最大化和關閉）。但是，特別是對於類似資訊亭的應用程式，不需要標題欄。您可以透過將 Window 物件的“no_titlebar”屬性設定為“True”來去除標題欄。

要終止此類應用程式，必須在發生退出按鈕事件時終止事件迴圈。

停用關閉的視窗

如果您希望阻止使用者最小化應用程式視窗，則應將 Window 物件的“disable_minimize”屬性設定為 True。類似地，將“disable_close”屬性設定為 True，關閉按鈕將顯示，但它不會建立 WINDOW_CLOSED 事件。

透明視窗

Window 物件的“alpha_channel”屬性決定視窗的透明度。其值介於 0 到 1 之間。預設情況下，它為 0，這意味著視窗顯示為不透明。將其設定為 1 以使其完全透明。0 到 1 之間的任何浮點值都會使透明度成比例。

多個視窗

PySimpleGUI 允許同時顯示多個視窗。PySimpleGUI 模組中的靜態函式在被呼叫時讀取所有活動視窗。要使視窗處於活動狀態，必須將其完成。該函式返回一個 (window, event, values) 結構的元組。

window, event, values = PySimpleGUI.read_all_windows()

如果沒有視窗開啟，則其返回值為 (None, WIN_CLOSED, None)

在以下程式碼中，兩個函式“win1()”和“win2()”在被呼叫時分別建立一個視窗。從第一個視窗開始，標題為 Window-2 的按鈕會開啟另一個視窗，以便兩者都處於活動狀態。當第一個視窗發生 CLOSED 事件時，兩者都關閉並且程式結束。如果按下第二個視窗的“X”按鈕，則將其標記為已關閉，第一個視窗保持開啟狀態。

import PySimpleGUI as psg
def win1():
   layout = [
      [psg.Text('This is the FIRST WINDOW'), psg.Text('', key='-OUTPUT-')],
      [psg.Text('popup one')],
      [psg.Button('Window-2'), psg.Button('Popup'), psg.Button('Exit')]
   ]
   return psg.Window('Window Title', layout, finalize=True)
   def win2():
      layout = [
         [psg.Text('The second window')],
         [psg.Input(key='-IN-', enable_events=True)],
         [psg.Text(size=(25, 1), key='-OUTPUT-')],
         [psg.Button('Erase'), psg.popup('Popup two'), psg.Button('Exit')]]
         return psg.Window('Second Window', layout, finalize=True)
window1 = win1()
window2 = None
while True:
   window, event, values = psg.read_all_windows()
   print(window.Title, event, values)
   if event == psg.WIN_CLOSED or event == 'Exit':
      window.close()
   if window == window2:
      window2 = None
   elif window == window1:
      break
   elif event == 'Popup':
      psg.popup('Hello Popup')
   elif event == 'Window-2' and not window2:
      window2 = win2()
   elif event == '-IN-':
      window['-OUTPUT-'].update('You entered {}'.format(values["-IN-"]))
   elif event == 'Erase':
      window['-OUTPUT-'].update('')
      window['-IN-'].update('')
window.close()

它將生成以下**輸出**視窗

非同步視窗

Window 類的**read()** 方法具有以下附加引數：

window.read(timeout = t, timeout_key=TIMEOUT_KEY, close=False)

**timeout** 引數允許您的 GUI 在非阻塞讀取情況下使用。它是您的裝置在返回之前可以等待的毫秒數。它使視窗能夠定期執行。

您能夠新增到 timeout 值的時間越長，您佔用的 CPU 時間就越少。在超時時間內，您正在“讓出”處理器以執行其他任務。您的 GUI 將比使用非阻塞讀取時更具響應性。

timeout_key 引數有助於確定在規定時間內是否發生任何使用者操作。 “timeout_key”的預設值為“__timeout__”。

while True:
   event, value = window.read(timeout=10)
   if event == sg.WIN_CLOSED:
      break
   if event == sg.TIMEOUT_KEY:
      print("Nothing happened")

要使視窗可移動，請將 Window 物件的“grab_anywhere”屬性設定為 true。如果“keep_on_top”屬性設定為 True，則視窗將始終位於當前視窗之上。

PySimpleGUI - 元素類

PySimpleGUI 庫包含許多可以放置在 Window 物件頂部的 GUI 小部件。例如，我們在上面示例中使用的按鈕或文字框。所有這些小部件實際上都是此庫中定義的類的物件，其中 Element 類充當所有其他小部件類的基類。

永遠不會顯式宣告此 Element 類的物件。它定義了諸如大小、顏色等通用屬性。以下是可用小部件（也稱為元素）的列表

Element 類的屬性

以下是 Element 類的屬性：

Element 類的 方法

以下是 Element 類的 方法：

PySimpleGUI - 事件

任何 GUI 應用程式都是事件驅動的，能夠響應 GUI 元素上發生的各種可能的事件。在 PySimpleGUI 中，事件處理在 GUI 設計構成之後的無限迴圈內完成，持續檢查是否發生事件並根據事件執行操作。

事件有兩種型別：

• 視窗事件，以及

• 元素事件。

視窗事件預設啟用，包括按鈕事件（當單擊任何按鈕時發生）和標題欄上“X”按鈕單擊的事件。

元素事件預設不啟用。只有在建立元素時將“enable_events”引數設定為 True 時，才能檢測到特定於元素的事件。

視窗關閉事件

使 PySimpleGUI 視窗保持持久的無限事件迴圈在使用者按下“X”按鈕或執行 Window 類的**close()**方法時終止。終止迴圈的標準方法如下：

import PySimpleGUI as psg
...
while True:
 ...

   if event == psg.WIN_CLOSED:
      break
 ...
window.close()

如果此引數設定為 True，則 Widow 類還會發出“enable_close_attempted_event”。在迴圈內檢測到它時呼叫是/否彈出視窗是一個好習慣。

window = psg.Window('Calculator', layout,  enable_close_attempted_event=True)
while True:
   event, values = window.read()
   print(event, values)
   if event == "Add":
      result = int(values['-FIRST-']) + int(values['-SECOND-'])
   if event == "Sub":
      result = int(values['-FIRST-']) - int(values['-SECOND-'])
   window['-OUT-'].update(result)
   if event == psg.WINDOW_CLOSE_ATTEMPTED_EVENT and psg.popup_yes_no('Do you really want to exit?') == 'Yes':
      break
   if event == psg.WIN_CLOSED or event == 'Exit':
      break

在這種情況下，當按下“X”按鈕時，會出現帶有是/否按鈕的彈出視窗，當單擊“是”按鈕時，程式退出。

它將生成以下輸出視窗：

事件值還會返回“-WINDOW CLOSE ATTEMPTED-”值。

-WINDOW CLOSE ATTEMPTED- {'-FIRST-': '200', '-SECOND-': '300'}

按鈕事件

按鈕單擊事件預設啟用。要停用，請使用“Button.update(disabled=True)”。您也可以在 Button 的建構函式中設定“enable_events=True”，它將啟用 Button Modified 事件。當某些內容“寫入”按鈕時，將觸發此事件。

當我們讀取視窗的內容（使用“window.read()”）時，按鈕值將是其標題（如果未設定鍵）或鍵（如果已設定）。

在上面的示例中，由於未在 Add 和 Sub 按鈕上設定 key 引數，因此在讀取視窗時會返回它們的標題。

Add {'-FIRST-': '200', '-SECOND-': '300'}

在程式中向 Add 和 Sub 按鈕新增 key 引數。

import PySimpleGUI as psg
layout = [
   [psg.Text('Enter a num: '), psg.Input(key='-FIRST-')],
   [psg.Text('Enter a num: '), psg.Input(key='-SECOND-')],
   [psg.Text('Result : '), psg.Text(key='-OUT-')],
   [psg.Button("Add", key='-ADD-'), psg.Button("Sub", key='- SUB-'), psg.Exit()],
]
window = psg.Window('Calculator', layout)
while True:
   event, values = window.read()
   print(event, values)

   if event == "-ADD-":
      result = int(values['-FIRST-']) + int(values['-SECOND-'])

   if event == "-SUB-":
      result = int(values['-FIRST-']) - int(values['-SECOND-'])

   window['-OUT-'].update(result)

   if event == psg.WIN_CLOSED or event == 'Exit':
      break
window.close()

read() 方法返回的元組現在將顯示所按按鈕的鍵。

-ADD- {'-FIRST-': '200', '-SECOND-': '300'}

其他元素的事件

許多元素在發生某種型別的使用者互動時會發出事件。例如，當移動滑塊時，或從列表中選擇專案時，或單擊單選按鈕時。

與 Button 或 Window 不同，這些事件預設不啟用。要為元素啟用事件，請設定引數“enable_events=True”。

下表顯示了元素及其生成的事件。

PySimpleGUI - 選單欄

大多數桌面應用程式都具有菜單系統，可以根據使用者在選單中選擇的選項觸發不同的操作。在一個典型的應用程式視窗中，選單欄位於標題欄下方和視窗的客戶區上方。

選單欄是一個由可點選按鈕組成的水平欄。當單擊這些按鈕中的任何一個時，它會生成一個選項按鈕的下拉列表。此類選項按鈕會觸發一個單擊事件，可以在事件迴圈內處理該事件。

菜單系統的設計方式與窗口布局的指定方式相同。它也是一個列表的列表。每個列表都有一個或多個字串。第一級列表的起始字串是出現在水平選單欄中的按鈕的標題。在其後是下拉選單中選項按鈕的標題字串列表。這些選項標題位於第一級列表內的列表中。

您可能在一個選項按鈕下有一個子選單，在這種情況下，標題將放在第三級列表中。同樣，標題可以巢狀到任何級別。

選單定義的通用格式如下所示

menu_def = [
   ['Memu1', ['btn1', 'btn2', 'btn3', 'btn4',]],
   ['menu2', ['btn5', 'btn6','btn7', 'btn8'],],
]

要將菜單系統附加到 PysimpleGUI 視窗的主佈局，請將 Menu 物件放在佈局的第一行。

Menu 建構函式以 **menu_def** 列表作為引數。在包含 Menu 物件的行之後，可以新增主佈局的其他行。

layout= [[psg.Menu(menu_def),[..], [..]]

在下面給出的程式碼中，我們有一個選單欄，包含檔案、編輯和幫助選單，每個選單欄中都有一些選單按鈕。

import PySimpleGUI as psg
menu_def = [['File', ['New', 'Open', 'Save', 'Exit', ]], ['Edit', ['Cut', 'Copy', 'Paste', 'Undo'], ],  ['Help', 'About...'], ]
layout = [[psg.Menu(menu_def)],
   [psg.Multiline("", key='-IN-',
   expand_x=True, expand_y=True)],
   [psg.Multiline("", key='-OUT-',
   expand_x=True, expand_y=True)],
   [psg.Text("", key='-TXT-',
   expand_x=True, font=("Arial Bold", 14))]
]
window = psg.Window("Menu", layout, size=(715, 300))
while True:
   event, values = window.read()
   print(event, values)

   if event != psg.WIN_CLOSED:
      window['-TXT-'].update(values[0] + "Menu Button Clicked")
   if event == 'Copy':
      txt = window['-IN-'].get()
   if event == 'Paste':
      window['-OUT-'].update(value=txt)
   if event == psg.WIN_CLOSED:
      break
window.close()

在選單欄下方放置了兩個多行元素。最後一行有一個文字元素。

當單擊任何選單選項按鈕時，生成的事件即為按鈕的標題。此標題將顯示在最後一行中的文字標籤上。請參考下圖 -

當發生複製事件時，帶有 -INkey 的上部多行框中的文字將儲存在 txt 變數中。之後，當按下貼上按鈕時，-OUT- 框將使用 txt 的值進行更新。

帶有熱鍵的選單按鈕

要將選單按鈕與鍵盤上的鍵對映，請在所需字元前放置一個 & 符號。例如，在 File 前放置 &，使字串為 '&File'。這樣做後，可以透過按下“Alt+F”鍵訪問檔案選單。“F”鍵被稱為熱鍵。

在我們的選單定義中新增選單按鈕的熱鍵。

menu_def = [
   ['&File', ['&New', '&Open', '&Save', 'E&xit',]],
   ['&Edit', ['C&ut', '&Copy','&Paste', '&Undo'],],
   ['&Help', '&About...'],
]

當代碼執行時，選單中的熱鍵將顯示為帶下劃線的字元。

右鍵單擊選單

此選單與應用程式視窗頂部的選單欄分離。每當使用者按下滑鼠的右鍵按鈕時，此選單都會彈出到單擊位置。

在上面定義的選單欄中，每個列表都是單個選單的定義。可以透過建構函式中的 right_click_menu 引數將此類單個選單定義附加到任何元素。在構建主視窗物件時也可以傳遞此引數。

讓我們使用 rightclick 作為對應於編輯選單的列表的變數。

rightclick=['&Edit', ['C&ut', '&Copy','&Paste', '&Undo']]
menu_def = [
   ['&File', ['&New', '&Open', '&Save', 'E&xit',]], rightclick,
   ['&Help', '&About...'],
]

在 Window 建構函式中將其用作 right_click_menu 引數的值。請參見以下程式碼片段 -

window=psg.Window("Menu", layout, size=(715, 300), right_click_menu=rightclick)

進行這些更改並執行程式碼。單擊視窗中的任意位置。選單將彈出，如下所示 -

ButtonMenu

此選單類似於右鍵單擊選單，但它附加到一個按鈕，並在單擊按鈕時彈出。

在主佈局的最後一行，我們添加了一個 ButtonMenu 元素，並使用 rightclick 列表作為其佈局。

layout= [
   [psg.Menu(menu_def)],
   [psg.Multiline("", key='-IN-', expand_x=True, expand_y=True)],
   [psg.Multiline("", key='-OUT-', expand_x=True, expand_y=True)],
   [psg.Text("", key='-TXT-', expand_x=True, font=("Arial Bold", 14)),
   psg.ButtonMenu('ButtonMenu', rightclick, key='-BMENU-')]
]

當單擊右下角的按鈕時，選單將彈出，如下圖所示 -

PySimpleGUI - Matplotlib 整合

當從 Python shell 使用 Matplotlib 時，繪圖將顯示在預設視窗中。**backend_tkagg** 模組可用於將繪圖嵌入到 Tkinter 中。

PySimpleGUI 中的 Canvas 元素具有返回原始 Tkinter 的 Canvas 物件的 TKCanvas 方法。它被傳遞給 backend_tkagg 模組中的 **FigureCanvasTkAgg()** 函式以繪製圖形。

首先，我們需要使用 **Figure()** 類和一個繪圖來建立圖形物件。我們將繪製一個顯示正弦波的簡單繪圖。

fig = matplotlib.figure.Figure(figsize=(5, 4), dpi=100)
t = np.arange(0, 3, .01)
fig.add_subplot(111).plot(t, 2 * np.sin(2 * np.pi * t))

定義一個函式，用於在畫布上繪製 matplotlib 圖形物件

def draw_figure(canvas, figure):
   figure_canvas_agg = FigureCanvasTkAgg(figure, canvas)
   figure_canvas_agg.draw()
   figure_canvas_agg.get_tk_widget().pack(side='top', fill='both', expand=1)
   return figure_canvas_agg

透過呼叫其 TkCanvas 屬性從 PySimpleGUI.Canvas 物件獲取 Canvas。

layout = [
   [psg.Text('Plot test')],
   [psg.Canvas(key='-CANVAS-')],
   [psg.Button('Ok')]
]

透過呼叫上述函式繪製圖形。將 Canvas 物件和圖形物件傳遞給它。

fig_canvas_agg = draw_figure(window['-CANVAS-'].TKCanvas, fig)

示例：繪製正弦波線形圖

完整的程式碼如下 -

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.backends.backend_tkagg import
FigureCanvasTkAgg
import PySimpleGUI as sg
import matplotlib
matplotlib.use('TkAgg')
fig = matplotlib.figure.Figure(figsize=(5, 4), dpi=100)
t = np.arange(0, 3, .01)
fig.add_subplot(111).plot(t, 2 * np.sin(2 * np.pi * t))
def draw_figure(canvas, figure):
   tkcanvas = FigureCanvasTkAgg(figure, canvas)
   tkcanvas.draw()
   tkcanvas.get_tk_widget().pack(side='top', fill='both', expand=1)
   return tkcanvas
layout = [[sg.Text('Plot test')],
   [sg.Canvas(key='-CANVAS-')],
   [sg.Button('Ok')]]
window = sg.Window('Matplotlib In PySimpleGUI', layout, size=(715, 500), finalize=True, element_justification='center', font='Helvetica 18')

# add the plot to the window
tkcanvas = draw_figure(window['-CANVAS-'].TKCanvas, fig)
event, values = window.read()
window.close()

生成的圖形如下 -

PySimpleGUI - 使用 PIL

Python 影像庫是一個免費的、跨平臺的、開源的 Python 程式語言庫，具有開啟、處理和儲存許多不同影像檔案格式的功能。

要安裝它，請使用以下 PIP 命令 -

pip3 install pillow

在以下示例中，我們使用 PIL 函式獲取 PNG 影像的位元組值，並在 PySimpleGUI 視窗上的 Image 元素中顯示相同的值。

import PySimpleGUI as sg
import PIL.Image
import io
import base64
def convert_to_bytes(file_or_bytes, resize=None):
   img = PIL.Image.open(file_or_bytes)
   with io.BytesIO() as bio:
      img.save(bio, format="PNG")
      del img
      return bio.getvalue()

imgdata = convert_to_bytes("PySimpleGUI_logo.png")
layout = [[sg.Image(key='-IMAGE-', data=imgdata)]]
window = sg.Window('PIL based Image Viewer', layout,resizable=True)
while True:
   event, values = window.read()
   if event == sg.WIN_CLOSED:
      break
window.close()

它將產生以下輸出視窗 -

PySimpleGUI - 偵錯程式

除了大多數 IDE（如 PyCharm 或 VS Code）內建的偵錯程式之外，PySimpleGUI 還提供了自己的偵錯程式。此偵錯程式使您能夠在程式碼執行時“檢視”和互動程式碼。

要有效地使用偵錯程式服務，應非同步讀取視窗，即應為 **read()** 函式提供超時。

偵錯程式視窗是透過在程式中的任何位置呼叫 **show_debugger_window()** 函式來呼叫的，如下所示 -

import PySimpleGUI as sg
sg.show_debugger_window(location=(10,10))
window = sg.Window('Debugger Demo',
   [[sg.Text('Debugger'),
   sg.Input('Input here'),
   sg.Button('Push Me')]]
)
while True:
   event, values = window.read(timeout=500)
   if event == sg.TIMEOUT_KEY:
      continue
   if event == sg.WIN_CLOSED:
      break
   print(event, values)
window.close()

PySimpleGUI 偵錯程式視窗將出現在指定的螢幕位置。

視窗顯示兩個選項卡“變數”和“REPL”。單擊“變數”選項卡。將顯示要自動監視的變數列表。選中您希望在程式執行期間監視的變數。

關於 REPL 的第二個選項卡提供了一個 Python 互動式控制檯，可以在程式的環境中執行，以便您可以檢查程式碼中所需變數的值。

PySimpleGUI - 設定

全域性設定

全域性設定是在應用程式範圍內可用的應用程式設定。這些設定控制 Element 類的各種屬性，以應用於應用程式中的所有元素。

這些設定以分層方式工作。如果為視窗提供了不同的值，則全域性設定將被覆蓋。依次為特定元素提供與 Window 物件中定義的設定不同的值。

例如，如果全域性將字型大小設定為 16，則所有元素的文字將相應顯示。但是，如果在佈局中定義了具有 Font 屬性且大小不為 16 的特定文字或輸入元素，則它將相應地更改外觀。

**set_options** 函式用於更改將在全域性應用的設定。如果它是一個應用於視窗的設定，則該設定不僅將應用於您建立的視窗，還將應用於彈出視窗。

import PySimpleGUI as sg
sg.set_options(font=('Arial Bold', 16))

使用者設定

“使用者設定”是一個自動寫入硬碟的字典。使用者設定儲存在 Python 字典中，該字典儲存到磁碟並從磁碟載入。因此，各個設定是字典中的鍵。

使用者設定函式列表 -

建立使用者設定物件。

settings = sg.UserSettings()

使用字典樣式的 [ ] 語法讀取設定。如果專案的名稱為“-item-”，則讀取值是透過編寫實現的

item_value = settings['-item-']

以下語句用於寫入設定。

settings['-item-'] = new_value

要刪除專案，再次使用字典樣式的語法。

del settings['-item-']

您還可以呼叫 delete_entry 方法來刪除條目。

settings.delete_entry('-item-')

以下簡單程式演示了使用者設定的載入/儲存

import PySimpleGUI as sg
import json
sg.set_options(font=('Arial Bold', 16))
layout = [
   [sg.Text('Settings', justification='left')],
   [sg.Text('User name', size=(10, 1), expand_x=True),
   sg.Input(key='-USER-')],
   [sg.Text('email ID', size=(10, 1), expand_x=True),
   sg.Input(key='-ID-')],
   [sg.Text('Role', size=(10, 1), expand_x=True),
   sg.Input(key='-ROLE-')],
   [sg.Button("LOAD"), sg.Button('SAVE'), sg.Button('Exit')]
]
window = sg.Window('User Settings Demo', layout, size=(715, 200))
# Event Loop
while True:
   event, values = window.read()
   if event in (sg.WIN_CLOSED, 'Exit'):
      break
   if event == 'LOAD':
      f = open("settings.txt", 'r')
      settings = json.load(f)
      window['-USER-'].update(value=settings['-USER-'])
      window['-ID-'].update(value=settings['-ID-'])
      window['-ROLE-'].update(value=settings['-ROLE-'])
   if event == 'SAVE':
      settings = {'-USER-': values['-USER-'],
      '-ID-': values['-ID-'],
      '-ROLE-': values['-ROLE-']}
      f = open("settings.txt", 'w')
      json.dump(settings, f)
      f.close()
window.close()

在輸入框中輸入資料，然後單擊“儲存”按鈕。

將儲存一個 JSON 檔案。要載入先前儲存的設定，請單擊“載入”按鈕。