Pysimplegui 简明教程

PySimpleGUI - Quick Guide

PySimpleGUI - Introduction

Python GUIs for Humans

PySimpleGui 项目最初是 TKinter 包的包装器，该包捆绑在 Python 的标准库中，其目标是简化 GUI 构建过程。

PySimpleGui 随后添加了基于 PySide 库（该库本身将最初用 C++ 编写的 Qt GUI 工具包移植到了 Python）和 WxPython（该库移植了另一个流行的 GUI 工具包 WxWidgets）设计桌面 GUI 的功能。这些库分别称为 PySimpleGUIQt 和 PySimpleGUIWx 。

PySimpleGui 系列的最新成员是 PySimpleGUIWeb 包，该包使用 Remi（远程接口库）构建在网页中呈现的 GUI 设计。

PySimpleGui 组中的所有包都遵循类似的 API，这意味着 GUI 元素、它们的属性和方法在所有四个包中都是相同的。因此，只需替换导入语句（并保持代码其余部分不变），就可以获得相应的 GUI 设计渲染。这实际上是 PySimpleGui 最重要的特性。这就是它被称为 Python GUIs for Humans. 的原因

Comparison with other GUI Frameworks

Python 程序员可以从各种 GUI 框架中进行选择来开发 GUI 应用程序。TKinter 是正式包含在 Python 标准库中的一个。其他的，其中大多数都是开源的，必须显式安装。

Sr.No.	Library & Description
1	TkInter包含在 Python 标准库中
2	PyQtQt 应用框架的 Python 3 绑定
3	PySide适用于 Python 的 Qt（以前称为 PySide）为跨平台应用和 UI 框架 Qt 提供了官方 Python 绑定
4	PySimpleGUIWraps tkinter、Qt (pyside2)、wxPython 以及 Remi（用于浏览器支持）在一个非 OOP API 中
5	wxPython支持 Windows/Unix/Mac。支持 Python 2.7 和 >=3.4。Wraps 和扩展 wxWidgets 工具链。
6	PyGObjectPyGObject 是一个 Python 包，它为基于 GObject 的库（例如 PyGtk 的 GTK 替换项）提供绑定。
7	PyForms一个 Python 框架，用于开发 GUI 应用程序，它以最小的工作量提升模块化软件设计和代码可重用性。

PySimpleGUI - Environment Setup

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

First Window using PySimpleGUI

要检查 PySimpleGUI 及其依赖关系是否已正确安装，请输入以下代码并使用任何 Python 感知编辑器将其保存为 "hello.py"。

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

上述代码构建一个窗口，其中包含一个文本元素（相当于 TKinter 中的标签），并在窗口的宽度上居中显示 "Hello World" 消息。

从命令终端运行此程序，如下所示 -

Python hello.py

该程序生成的 output 应该与下面显示的类似 -

Equivalent Tkinter Code

要使用纯 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 消息会像以前一样显示。

可以将可调用类用作视图，而不要使用函数。可调用类是覆盖 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 移植）中定义的小部件兼容。PySimpleGui 的 Qt 版本称为 PySimpleGUIQt。它可以通过以下 PIP 命令进行类似安装：

pip3 install PySimpleGUIQt

由于此包依赖于 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()

output 非常相似。

Equivalent PySide2 Code

实现相同结果的纯 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 是针对广泛使用的 WxWidgets 库（最初用 C++ 编写）的 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()

它将生成以下 output ：

请注意，您需要更复杂的代码才能使用 pure WxPython code 获得类似输出，如下所示：

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（远程接口）是用于 Python 应用程序的 GUI 库，这些应用程序在 Web 浏览器中呈现。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 程序。我们可以看到小部件库保持不变。此外，相同的 Hello World 程序，当分别用纯 Tkinter、PySide、WxPython 和 Remi 编写时，比 PySimpleGUI 版本复杂且繁琐得多。

PySimpleGUI - Popup Windows

PySimpleGUI 模块中以弹出窗口*前缀开头的函数会生成具有预定义外观的窗口。弹出窗口函数的名称表示其目的是否在其中提供按钮的配置。这些弹出窗口仅使用一行代码创建。每个弹出窗口都有特定的目的，然后立即关闭。

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 − 显示日历窗口，获取用户选择，以元组 (mon, day, year) 的形式返回

当用户完成选择并按下确定按钮时，弹出窗口的返回值为文本，可以在程序中进一步使用。

以下脚本显示了如何使用上述一些弹出窗口 −

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

Output − 下面显示了上述代码生成的弹出窗口 −

Python console 上显示以下 output −

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

所有类型弹出窗口都是继承自弹出窗口类的各个类的对象。它们都具有相同的一组属性。这些属性具有特定的默认值，并可用于自定义弹出窗口对象的外观和行为。下表列出了通用参数 −

Type

Parameter

Description

Any

*args

要在弹出窗口上显示的值

Str

title

窗口的可选标题。

(str, str) or None

button_color

显示的按钮颜色（文本颜色、按钮颜色）

Str

background_color

Window’s background color

Str

text_color

text color

Bool

auto_close

如果为 True，则窗口将自动关闭

Int

auto_close_duration

在自动关闭窗口之前保持窗口处于打开状态的时间（以秒为单位）

Bool

non_blocking

如果为 True，则将立即从函数返回，而无需等待用户输入。

Tuple[font_name, size, modifiers]

font

指定字体系列、大小等。元组或单字符串格式 'name size styles'。

Bool

grab_anywhere

如果为 True，则可以在任何地方点击以移动窗口。

(int, int)

Location

显示窗口的左上角在屏幕上的位置。默认为窗口在屏幕上居中

Bool

keep_on_top

如果为 True，窗口将保持在所有当前窗口之上

Bool

modal

如果为 True，则弹出窗口将表现得像模式窗口。默认 = True

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

它将生成以下 output −

Progress Meter

“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'
   )

它将生成以下 output 窗口 −

Debug Popup

在程序运行期间，通常需要跟踪某些变量的中间值，虽然后续的输出中不需要这些值。可以使用 PySimpleGUI 库中的 Print() 函数来实现此目的。

Note − 与 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，调试窗口会显示以下 output −

PySimpleGUI - Window Class

弹出式窗口拥有按钮、文本标签和文本输入域的预定义配置。Window 类允许你设计出更加灵活的 GUI。除了这些元素，还提供其他元素，比如列表框、复选框、单选按钮等。你还可以向 GUI 提供菜单系统。某些专门的小部件，例如进度条、滑块等，也可以用来使设计更加有效。

窗口可以是非持久性窗口，类似于弹出式窗口。它会阻塞程序流，直至用户点击客户端区域上的按钮或标题栏上的关闭 (X) 按钮将其关闭。

另一方面，持久性窗口会一直保持可见，直至导致其关闭的事件发生。异步窗口是一种其内容会定期更新的窗口。

Layout Structure

窗口的客户端区域中元素或小部件放置由列表对像列表控制。每个列表元素对应于窗口界面上的一行，并且可以包含 PySimpleGUI 库中提供的一个或多个 GUI 元素。

第一步是通过如下方式进行绘制，可视化元素的放置位置：

窗口上的元素被放置在四行中。前三行包含一个 Text 元素（显示静态文本）和一个 InputText 元素（其中用户可以输入）。最后一行包含两个按钮，Ok 和 Cancel。

这在列表列表中以如下方式表示：

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 的字典中。随着用户按下 Ok 按钮，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()

以下是如何 output 显示的：

如所示输入数据并按下“OK”按钮。值会按如下方式打印：

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

如果在填写数据后，你按下“Cancel”按钮，打印结果将是：

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

Persistent Window

请注意，此窗口在点击任何按钮（或标题栏中的“X”按钮）后会立即关闭。若要在按下名为 Exit 的特殊类型的按钮或通过按下“X”关闭窗口时保持窗口处于活动状态，则将 read() 方法放入一个无限循环中，该循环允许在 WIN_CLOSED 事件（在按下 Exit 按钮时）或 Exit 事件（在按下“X”按钮时）发生时中断。

让我们在上面的代码中将 Cancel 按钮更改为 Exit 按钮。

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

窗口的外观将与之前类似，只是它不再具有 Cancel 按钮，而是 Exit 按钮。

输入的数据将以元组的形式打印。第一个元素是事件，即按钮标题，第二个元素是字典，其键是增量数字，值是输入的文本。

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 Methods

Window 类中定义的重要方法是 read() 方法，用于收集所有输入元素中输入的值。Window 类还有其他方法来自定义外观和行为。它们如下所列：

Sr.No.	Method & Description
1	AddRow 将元素的单行添加到窗口的“self.Rows”变量中
2	AddRows循环遍历包含元素的元素列表，并向布局添加每个行（列表）。
3	close关闭窗口以恰当地释放资源。
4	disable禁止窗口获取用户的任何输入
5	disappear导致窗口从屏幕“消失”，但仍保留在任务栏中。
6	enable重新启用窗口以获取用户输入
7	fill填充用作字典提供的的数据作为输入字段的元素。
8	find_element 查找与提供的键关联的元素对象。它相当于“元素=窗口[键]”
9	get_screen_dimensions 获取屏幕尺寸。
10	hide从屏幕和任务栏中隐藏窗口（窗口）。
11	load_from_disk从“SaveToDisk”函数创建的 Pickle 文件中恢复值
12	layout使用小组件列表填充窗口。
13	read从窗口获取所有数据。传入一个超时时间（以毫秒为单位）来等待。
14	reappear导致消失的窗口再次显示。
15	save_to_disk将包含在每个输入元素中的值保存到 pickle 文件中。
16	set_title 更改任务栏中的窗口标题

Update Window with Key

用户在窗口布局的不同输入元素中输入的数据将以字典格式存储。字典键（从 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']

但是，如果要以编程方式操作元素的值，则必须将元素初始化为将其键参数指定为唯一的字符串值。元素的键类似于变量或标识符的名称，这使得以编程方式方便地处理读取或向其分配值。

键参数应为字符串。惯例是它应该是大写字符串，前面和后面都跟着一个“-”字符（示例：“- 名称 -”）。然而，任何字符串都可以使用。

让我们如下所示将键分配给上面的示例中的输入元素 −

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”。可以将键分配给任何元素，而不仅仅是输入元素。可以使用相同的键对元素调用更新。我们可以使用窗口对象的“find_element(key)”或使用 window['key'] 引用该元素。

让我们扩展先前的示例，在“确定”和“取消”按钮之前添加一行，并添加一个具有“-OUT-”键的空文本元素。在“确定”事件中，此文本标签将显示在具有“-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()

运行上述代码，在三个输入元素中输入文本并按“确定”。-OUT- 文本标签将按此处所示进行更新 −

在下面提供了键属性的另一个使用示例。向输入元素分配关键参数 -FIRST- 和 -SECOND-。有两个按钮加号和减号。文本元素显示根据按下的按钮加或减两个数字。

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

以下屏幕截图显示了按下“添加”按钮时的结果。

Borderless Window

默认情况下，应用程序窗口在客户端区域上方创建标题栏，其中所有其他元素都放置在布局中。标题栏在左侧包含窗口标题，在右侧包含控件按钮（最小化、还原/最大化和关闭）。但是，特别对于类似信息亭的应用程序，不需要标题栏。可以通过将窗口对象的“no_titlebar”属性设置为“True”来摆脱标题栏。

要终止此类应用程序，必须在退出按钮事件发生时终止事件循环。

Window with Disabled Close

如果你希望阻止用户最小化应用程序窗口，则应将窗口对象的“disable_minimize”属性设置为 True。类似地，对“disable_close”属性设置为 True，则关闭按钮显示，但它不会创建 WINDOW_CLOSED 事件。

Transparent Window

窗口对象的“alpha_channel”属性决定了窗口的透明度。它的值在 0 到 1 之间。默认值为 0，这意味着窗口显示为不透明。将其设置为 1 以使其完全透明。0 到 1 之间的任何浮点数使透明度成比例。

Multiple Windows

PySimpleGUI 允许同时显示多个窗口。PySimpleGUI 模块中的静态函数在调用时读取所有活动窗口。要激活窗口，必须对其进行最终确定。该函数返回一个（窗口、事件、值）结构的元组。

window, event, values = PySimpleGUI.read_all_windows()

如果没有打开窗口，其返回值为 (None, WIN_CLOSED, None)

在以下代码中，两个函数 “win1()” 和 “win2()” 在调用时各创建一个窗口。从第一个窗口开始，标题为“窗口-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()

它将生成以下 output 窗口：

Asynchronous Window

窗口类的 read() 方法具有以下附加参数 −

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

timeout 参数允许你的 GUI 在非阻塞读取情况下使用。这是设备在返回之前可以等待的毫秒数。它创建一个定期运行的窗口。

你能够添加到超时值的时间越长，你占用的 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")

若要使窗口可移动，可将窗口对象的“grab_anywhere”属性设置为真。如果将“keep_on_top”属性设置为真，则窗口将始终位于当前窗口之上。

PySimpleGUI - Element Class

PySimpleGUI 库包含许多 GUI 小组件，可将其放置在窗口对象之上。例如，我们在上述示例中使用的按钮或文本框。所有这些小组件实际上都是此库中定义的类的对象，其中 Element 类充当所有其他小组件类的基础。

这种 Element 类对象永远不会显式声明。它定义了诸如大小、颜色等通用属性。以下是可用小组件（也称为元素）的列表

Sr.No.	Widget & Description
1	Text Element 在窗口中显示一些文本。通常这意味着单行文本。
2	Input Element 显示一个文本输入字段。
3	多行元素显示和/或读取多行文本。这是一个输入和输出元素。
4	Combo Element 单行输入和下拉菜单的组合。
5	OptionMenu 元素类似于 Combo。仅用于 TKinter 端口
6	Checkbox Element 显示一个复选框及旁边的文本。
7	Radio Element 用于一组其他单选元素中，以便用户能够在选项列表中只选择一个选项。
8	Spin Element 带上下按钮和单行文本的旋转器。
9	按钮元素定义所有可能的按钮。诸如 Submit、FileBrowse、… 等快捷方式各创建一个按钮
10	ButtonMenu element 创建一个按钮，当单击该按钮时，将显示一个类似于右键单击菜单的菜单。
11	Slider Element 用于递增/递减值的水平或垂直滑块。
12	Listbox Element 向用户提供一个值列表，以便用户选择一个或多个值。当执行 window.read() 时，会返回一个所选行的列表。
13	Image Element 在窗口中显示图像。只能是 GIF 或 PNG。
14	Graph Element 创建绘图区域
15	Canvas Element 用于绘制形状的区域
16	ProgressBar Element 显示随着某个操作的进度而阴影化的彩色条形图。
17	Table Element 以行和列显示数据
18	Tree Element 以树形呈现数据，很像文件/文件夹浏览器。
19	Sizer 元素此元素用于增加更多空间。
20	StatusBar 元素StatusBar 元素创建底部凹陷的文本填充条带。
21	Frame Element Frame 元素是一个容器对象，可容纳一个或多个其他类型的元素。
22	Column Element 如果你想以一个或多个垂直列表示 GUI 窗口元素，那它非常有用。
23	Tab Element 使用 Tab 元素使得设计非常方便、高效，且便于用户导航。Tab 元素也是一个容器元素，例如 Frame 或 Column。

Properties of Element Class

以下是元素类的属性 −

Sr.No.	Property & Description
1	size(w=characters-wide, h=rows-high)
2	font指定字体系列、大小
3	background_colorcolor of background
4	text_colorelement’s text color
5	keyIdentifies an Element
6	visible设置元素的可见性状态（默认 = 真）

Methods of Element Class

以下是元素类的方法 −

Sr.No.	Method & Description
1	set_tooltip()由应用程序调用以更改元素的工具提示文本
2	set_focus()设置当前焦点在此元素上
3	set_size()将元素的大小更改为特定大小
4	get_size()以像素为单位返回元素大小
5	expand()使元素扩展以填充 X 和 Y 方向的可用空间
6	*set_cursor()：设置当前元素的光标
7	set_right_click_menu()设置在单击时调用的右键单击菜单

PySimpleGUI - Events

任何 GUI 应用程序都是事件驱动的，它有能力响应 GUI 元素上发生的各种可能的事件。在 PySimpleGUI 中，事件处理在 GUI 设计的结构下面一个无限循环中完成，不断检查是否发生了事件并根据事件执行动作。

有两种类型的事件 −

Window events, and
Element events.

窗口事件默认启用，包括按钮事件（当单击任何按钮时发生）和标题栏上“X”按钮的事件。

元素事件默认不会启用。只有当在创建元素时将“enable_events”参数设置为 True 时，才能检测到特定于元素的事件。

Window Closed Event

一个无限事件循环使 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 Events

按钮单击事件默认启用。要禁用，请使用“Button.update(disabled=True)”。您还可以在按钮的构造函数中设置“enable_events=True”，它将启用 Button Modified 事件。当有内容“写入”到按钮时触发此事件。

当我们读取窗口的内容（使用“window.read()”）时，按钮值将是其标题（如果未设置键）或已设置则为键。

在上述示例中，由于未在 Add 和 Sub 按钮上设置键参数，因此在读取窗口时将返回它们的标题。

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

在程序中向 Add 和 Sub 按钮添加键参数。

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'}

Events of Other Elements

当发生某种类型的用户交互时，许多元素会发出事件。例如，当移动滑块或从列表中选择一个项目或单击单选按钮时。

与 Button 或 Window 不同，这些事件默认不会启用。要为元素启用事件，请将参数“enable_events=True”设置为。

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

Name

Events

InputText

any key pressed

Combo

item selected

Listbox

selection changed

Radio

selection changed

Checkbox

selection changed

Spinner

new item selected

Multiline

any key pressed

Text

Clicked

Status Bar

Clicked

Graph

Clicked

Graph

Dragged

Graph

drag ended (mouse up)

TabGroup

tab clicked

Slider

slider moved

Table

row selected

Tree

node selected

ButtonMenu

menu item chosen

Right click menu

menu item chosen

PySimpleGUI - Menubar

大多数桌面应用程序都具有菜单系统，以根据用户在菜单中选择的选项触发不同的操作。在典型的应用程序窗口中，菜单栏位于标题栏的正下方，并且处于窗口客户端区域的上方。

菜单栏是一个由可点击按钮组成的水平栏。当单击其中任何按钮时，它将生成下拉选项按钮列表。此类选项按钮触发可在事件循环中处理的单击事件。

菜单系统就像所指定的窗口布局一样进行设计。它也是列表的列表。每个列表包含一个或多个字符串。第一级列表的起始字符串是出现在水平菜单栏中的按钮标题。其后是下拉菜单中选项按钮的标题字符串列表。这些选项标题位于第一级列表中的列表中。

在选项按钮下方可以有子菜单，在这种情况下，标题将被放入第三级列表中。同样，标题可以嵌套到任何级别。

菜单定义的一般格式如下：

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

要将菜单系统附加到 PysimpleGUI 窗口的主布局，请将 Menu 对象放置在布局的第一行。

Menu 构造函数以 menu_def 列表作为参数提供。菜单对象的所在行后面可能会出现主布局的其他行。

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

在菜单栏下方，放置了两个多行元素。最后一行有一个文本元素。

单击任何菜单选项按钮时，生成的事件是按钮的标题。此标题显示在最后一行中的 Text 标签上。参考下图 -

当 Copy 事件发生时，带有 -INkey 的上部多行方框中的文本存储在 txt 变量中。此后，当按下 Paste 按钮时，-OUT- 框会使用 txt 的值进行更新。

Menu button with Hot Key

要在菜单按钮和键盘上的键之间建立映射，请在所需的字符前放置一个与符号 &。例如，在 File 前面加上 &，使字符串为“&File”。通过此操作，可以通过按 "Alf+F" 键来访问 File 菜单。此处“F”键被称为热键。

将热键添加到菜单定义中的菜单按钮。

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

运行代码时，菜单中的热键将显示为带下划线的形式。

Right-click Menu

此菜单从位于应用程序窗口顶部的菜单栏中分离出来。每当用户按下鼠标右键按钮时，此菜单都会在单击发生的位置弹出。

在上面定义的菜单栏中，每个列表都是单个菜单的定义。这样的单个菜单定义可以通过构造函数中的 right_click_menu 参数附加到任何元素。在构造主 Window 对象时，也可以传递此参数。

让我们使用 rightclick 作为与 Edit 菜单相对应的列表的变量。

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 Integration

当在 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 对象获取画布。

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

调用上述函数绘制图形。将画布对象和图形对象传递给它。

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

Example: Draw a Sinewave Line graph

以下是完整代码 −

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 - Working with PIL

Python Imaging Library 是 Python 编程语言的一个免费、跨平台开源库，它具有打开、处理和保存许多不同图像文件格式的功能。

要安装此应用，使用 PIP 命令，如下所示 −

pip3 install pillow

在以下示例中，我们使用 PIL 函数获取 PNG 图像的字节值，然后在 PySimpleGUI 窗口上的图像元素中显示相同的字节值。

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

它将生成以下 output 窗口 −

PySimpleGUI - Debugger

除了大多数 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 - Settings

Global Settings

全局设置是可在整个应用程序范围内使用的应用程序设置。这些设置控制 Element 类用于应用于应用程序中所有元素的各种属性。

这些设置以分级方式起作用。如果这些设置针对窗口提供了其他值，则全局设置将被覆盖。反过来，Window 对象中定义的设置针对特定元素提供了不同的值。

例如，如果在全局范围内将字号设置为 16，则所有元素的文本都将相应显示。但是，如果布局中定义了具有 16 以外大小的字体属性的特定文本或输入元素，则它将相应更改外观。

set_options 函数用于更改在全局范围内应用的设置。如果这是应用于 Windows 的设置，则该设置不仅适用于你创建的 Windows，还适用于弹出式 Windows。

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

User Settings

“用户设置”是一个自动写入到硬盘的字典。用户设置存储在 Python 字典中，并保存到磁盘并从磁盘中加载。因此，各个设置是放入字典中的键。

用户设置函数列表 -

Sr.No.	Function & Description
1	user_settings以字典形式返回设置
2	user_settings_delete_entryDeletes a setting
3	user_settings_delete_filenameDeletes the settings file
4	user_settings_file_exists如果存在指定的文件设置，则返回真
5	user_settings_filename返回文件设置的完整路径和文件名
6	user_settings_get_entry返回设置的值。如果未找到设置，则返回指定默认值
7	user_settings_load从文件设置中加载字典。
8	user_settings_save 将设置保存到当前或新指定的文件中。
9	user_settings_set_entry为一个特定值设置一项
10	user_settings_write_new_dictionary将指定的词典写入设置文件

创建用户设置对象。

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

Sr.No.	Library & Description
1	TkInter包含在 Python 标准库中
2	PyQtQt 应用框架的 Python 3 绑定
3	PySide适用于 Python 的 Qt（以前称为 PySide）为跨平台应用和 UI 框架 Qt 提供了官方 Python 绑定
4	PySimpleGUIWraps tkinter、Qt (pyside2)、wxPython 以及 Remi（用于浏览器支持）在一个非 OOP API 中
5	wxPython支持 Windows/Unix/Mac。支持 Python 2.7 和 >=3.4。Wraps 和扩展 wxWidgets 工具链。
6	PyGObjectPyGObject 是一个 Python 包，它为基于 GObject 的库（例如 PyGtk 的 GTK 替换项）提供绑定。
7	PyForms一个 Python 框架，用于开发 GUI 应用程序，它以最小的工作量提升模块化软件设计和代码可重用性。

Sr.No.	Method & Description
1	AddRow 将元素的单行添加到窗口的“self.Rows”变量中
2	AddRows循环遍历包含元素的元素列表，并向布局添加每个行（列表）。
3	close关闭窗口以恰当地释放资源。
4	disable禁止窗口获取用户的任何输入
5	disappear导致窗口从屏幕“消失”，但仍保留在任务栏中。
6	enable重新启用窗口以获取用户输入
7	fill填充用作字典提供的的数据作为输入字段的元素。
8	find_element 查找与提供的键关联的元素对象。它相当于“元素=窗口[键]”
9	get_screen_dimensions 获取屏幕尺寸。
10	hide从屏幕和任务栏中隐藏窗口（窗口）。
11	load_from_disk从“SaveToDisk”函数创建的 Pickle 文件中恢复值
12	layout使用小组件列表填充窗口。
13	read从窗口获取所有数据。传入一个超时时间（以毫秒为单位）来等待。
14	reappear导致消失的窗口再次显示。
15	save_to_disk将包含在每个输入元素中的值保存到 pickle 文件中。
16	set_title 更改任务栏中的窗口标题

Sr.No.	Property & Description
1	size(w=characters-wide, h=rows-high)
2	font指定字体系列、大小
3	background_colorcolor of background
4	text_colorelement’s text color
5	keyIdentifies an Element
6	visible设置元素的可见性状态（默认 = 真）

Sr.No.	Method & Description
1	set_tooltip()由应用程序调用以更改元素的工具提示文本
2	set_focus()设置当前焦点在此元素上
3	set_size()将元素的大小更改为特定大小
4	get_size()以像素为单位返回元素大小
5	expand()使元素扩展以填充 X 和 Y 方向的可用空间
6	*set_cursor()：设置当前元素的光标
7	set_right_click_menu()设置在单击时调用的右键单击菜单

Sr.No.	Function & Description
1	user_settings以字典形式返回设置
2	user_settings_delete_entryDeletes a setting
3	user_settings_delete_filenameDeletes the settings file
4	user_settings_file_exists如果存在指定的文件设置，则返回真
5	user_settings_filename返回文件设置的完整路径和文件名
6	user_settings_get_entry返回设置的值。如果未找到设置，则返回指定默认值
7	user_settings_load从文件设置中加载字典。
8	user_settings_save 将设置保存到当前或新指定的文件中。
9	user_settings_set_entry为一个特定值设置一项
10	user_settings_write_new_dictionary将指定的词典写入设置文件