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

Explore our latest online courses and learn new skills at your own pace. Enroll and become a certified expert to boost your career.

使用 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 文件。要加载先前保存的设置，请单击“加载”按钮。