PySimpleGUI

PySimpleGUI é um pacote Python que permite que programadores Python de todos os níveis
criem GUIs. Você especifica sua janela GUI usando um "layout" que contém widgets (eles são
chamados de "Elementos" em PySimpleGUI). Seu layout é usado para criar uma janela usando
uma das 4 estruturas suportadas para exibir e interagir com sua janela. As estruturas com suporte
incluem tkinter, Qt, WxPython ou Remi. O termo "invólucro" às vezes é usado para esses tipos de
pacotes.

Seu código PySimpleGUI é mais simples e mais curto do que escrever diretamente usando a
estrutura subjacente porque PySimpleGUI implementa muito do "código clichê" para você. Além
disso, as interfaces são simplificadas para exigir o mínimo de código possível para obter o
resultado desejado. Dependendo do programa e da estrutura usados, um programa PySimpleGUI
pode exigir 1/2 a 1/10 da quantidade de código para criar uma janela idêntica usando uma das
estruturas diretamente.

Embora o objetivo seja encapsular / ocultar os objetos e códigos específicos usados pela estrutura
da GUI que você está executando, se necessário, você pode acessar os widgets e janelas
dependentes das estruturas diretamente. Se uma configuração ou recurso ainda não foi exposto
ou acessível usando as APIs PySimpleGUI, você não está isolado da estrutura. Você pode
expandir os recursos sem modificar diretamente o próprio pacote PySimpleGUI.

Exemplo 1 - A janela One-Shot

Este tipo de programa é chamado de janela "one-shot" porque a janela é exibida uma vez, os
valores coletados, e depois é fechada. Não permanece aberto por muito tempo como você faria
em um processador de texto.

Anatomia de um programa PySimpleGUI simples

Existem 5 seções para um programa PySimpleGUI

importar PySimpleGUI como sg # Parte 1 - A importação

# Defina o

layout do conteúdo da janela = [ [ sg . Texto ( "Qual é o seu nome?" )], # Parte 2 - O Layout

[ sg . Input ()],

[ sg . Botão ( 'Ok' )] ]
 # Crie a janela

window = sg . Janela ( 'Título da janela' , layout ) # Parte 3 - Definição da janela

# Exibir e interagir com o

evento Window , values = window . read () # Parte 4 - Loop de evento ou chamada de

Window.read

# Faça algo com as informações coletadas

print ( 'Hello' , values [ 0 ], "! Obrigado por experimentar o PySimpleGUI" )

# Termine removendo da

janela da tela . close () # Parte 5 - Fechar a janela

O código produz esta janela

Exemplo 2 - janela interativa

Neste exemplo, nossa janela permanecerá na tela até que o usuário feche a janela ou clique no
botão Sair. A principal diferença entre a janela instantânea que você viu anteriormente e uma
janela interativa é a adição de um "Loop de evento". O loop de eventos lê eventos e entradas de
sua janela. O coração de seu aplicativo reside no loop de eventos.

importar PySimpleGUI como sg

# Defina o

layout do conteúdo da janela = [[ sg . Texto ( "Qual é o seu nome?" )],

[ Sg . Input ( key = '-INPUT-' )],

 [ sg . Texto ( tamanho = ( 40 , 1 ), chave = '-OUTPUT-' )],

[ sg . Botão ( 'Ok' ), sg . Botão ( 'Sair' )]]

# Crie a janela

window = sg . Janela ( 'Título da janela' , layout )

# Exibir e interagir com a janela usando um loop de eventos

enquanto True :

evento , valores = janela . read ()

# Veja se o usuário deseja sair ou a janela foi fechada

se o evento == sg . WINDOW_CLOSED ou evento == 'Sair' :

break

Envia uma mensagem para a janela da janela [ '-OUTPUT-' ] . update ( 'Hello' + values [ '-INPUT-' ]
+ "! Obrigado por experimentar o PySimpleGUI" )

# Termine removendo da

janela da tela . fechar ()

Esta é a janela que o Exemplo 2 produz.

E é assim que fica depois que você insere um valor no campo de entrada e clica no botão OK.
Vamos dar uma olhada rápida em algumas das diferenças entre este exemplo e a janela única.

Primeiro, você notará diferenças no layout. Duas mudanças em particular são importantes. Um é a
adição do key parâmetro ao Input elemento e um dos Text elementos. A key é como o nome de
um elemento. Ou, em termos Python, é como uma chave de dicionário. A Input chave do elemento
será usada como uma chave de dicionário posteriormente no código.

Outra diferença é a adição deste Text elemento:

[ sg . Texto ( tamanho = ( 40 , 1 ), chave = '-OUTPUT-' )],

Existem 2 parâmetros, os key que já cobrimos. O size parâmetro define o tamanho do elemento
em caracteres. Nesse caso, estamos indicando que este Text elemento tem 40 caracteres de
largura e 1 caractere de altura. Observe que não há string de texto especificada, o que significa
que ficará em branco. Você pode ver facilmente esta linha em branco na janela que foi criada.

Também adicionamos um botão "Sair".

O loop de eventos tem nossa window.read() chamada familiar .

Após a leitura está esta declaração if:

se evento == sg . WINDOW_CLOSED ou evento == 'Sair' :

pausa

Este código está verificando se o usuário fechou a janela clicando no "X" ou se clicou no botão
"Sair". Se alguma dessas coisas acontecer, o código sairá do loop de eventos.

Se a janela não foi fechada nem o botão Sair clicado, a execução continua. A única coisa que
poderia ter acontecido é o usuário clicar no botão "Ok". A última instrução no loop de eventos é
esta:

janela [ '-OUTPUT-' ] . update ( 'Hello' + values [ '-INPUT-' ] + "! Obrigado por experimentar o
PySimpleGUI" )
Esta instrução atualiza o Text elemento que possui a chave -OUTPUT- com uma string. window['-
OUTPUT-'] encontra o elemento com a chave -OUTPUT- . Essa chave pertence ao
nosso Text elemento em branco . Depois que esse elemento é retornado da pesquisa,
seu update método é chamado. Quase todos os elementos têm um update método. Este método
é usado para alterar o valor do elemento ou para alterar alguma configuração do elemento.

Se quisermos que o texto seja amarelo, isso pode ser feito adicionando um text_color parâmetro
ao update método para que leia:

janela [ '-OUTPUT-' ] . update ( 'Hello' + values [ '-INPUT-' ] + "! Obrigado por experimentar o
PySimpleGUI" ,

text_color = 'amarelo' )

Depois de adicionar o text_color parâmetro, esta é nossa nova janela resultante:

Os parâmetros disponíveis para cada elemento são documentados na documentação de

referência da chamada e também nas docstrings. O PySimpleGUI possui uma extensa
documentação para ajudá-lo a entender todas as opções disponíveis. Se você pesquisar
o update método do Text elemento, encontrará esta definição para a chamada:
Como você pode ver, várias coisas podem ser alteradas para um Text elemento. A documentação
de referência da chamada é um recurso valioso que tornará a programação em PySimpleGUI,
uhm, simples.

Layouts são engraçados

O layout da sua janela é uma "lista de listas" (LOL). As janelas são divididas em "linhas". Cada
linha em sua janela se torna uma lista em seu layout. Concatene todas as listas e você terá um
layout ... uma lista de listas.

Aqui está o mesmo layout de antes, com um Text elemento extra adicionado a cada linha para que
você possa ver mais facilmente como as linhas são definidas:

layout = [ [ sg . Texto ( 'Linha 1' ), sg . Texto ( "Qual é o seu nome?" )],

[ Sg . Texto ( 'Linha 2' ), sg . Input ()],

[ sg . Texto ( 'Linha 3' ), sg . Botão ( 'Ok' )] ]

Cada linha desse layout é uma lista de elementos que serão exibidos nessa linha da janela.
Usar listas para definir sua GUI tem algumas vantagens enormes sobre como a programação da
GUI é feita usando outras estruturas. Por exemplo, você pode usar a compreensão de lista do
Python para criar uma grade de botões em uma única linha de código.

Estas 3 linhas de código:

importar PySimpleGUI como sg

layout = [[ sg . Botão ( f ' { linha } , { col } ' ) para coluna no intervalo ( 4 )] para linha no intervalo (
4 )]

evento , valores = sg . Janela ( 'Listar compreensões' , layout ) . ler ( fechar = Verdadeiro )

produz esta janela que tem uma grade 4 x 4 de botões:

Lembre-se de como "diversão" é um dos objetivos do projeto. É divertido aplicar diretamente os

poderosos recursos básicos do Python a problemas de GUI. Em vez de páginas de código para
criar uma GUI, são algumas (ou geralmente 1) linhas de código.

Código de recolhimento

É possível condensar o código de uma janela em uma única linha de código. A definição do layout,
a criação da janela, a exibição e a coleta de dados podem ser escritas nesta linha de código:
 evento , valores = sg . Janela ( 'Título da janela' , [[ sg . Text ( "Qual é o seu nome?" )], [ Sg . Input
()], [ sg . Button ( 'Ok' )]]) . ler ( fechar = Verdadeiro )

A mesma janela é mostrada e retorna os mesmos valores que o exemplo que mostra as seções
de um programa PySimpleGUI. Ser capaz de fazer tanto com tão pouco permite que você
adicione GUIs de forma rápida e fácil ao seu código Python. Se você deseja exibir alguns dados e
obter uma escolha do usuário, isso pode ser feito em uma linha de código em vez de em uma
página de código.

Usando apelidos abreviados, você pode economizar ainda mais espaço em seu código usando
menos caracteres. Todos os elementos têm um ou mais nomes mais curtos que podem ser
usados. Por exemplo, o Text elemento pode ser escrito simplesmente como T . O Input elemento
pode ser escrito como I e Button como B . Seu código de janela de linha única torna-se:

evento , valores = sg . Window ( 'Window Title' , [[ sg . T ( "Qual é o seu nome?" )], [ Sg . I ()], [ sg . B
( 'Ok' )]]) . ler ( fechar = Verdadeiro )

Portabilidade de código

PySimpleGUI é atualmente capaz de rodar em 4 Python GUI Frameworks. A estrutura a ser usada
é especificada usando a instrução import. Altere a importação e você alterará a estrutura GUI
subjacente. Para alguns programas, nenhuma outra mudança é necessária além da instrução
import para rodar em uma estrutura GUI diferente. No exemplo acima, mudando a importação a
partir PySimpleGUI de PySimpleGUIQt , PySimpleGUIWx , PySimpleGUIWeb vai mudar o quadro.
Declaração de
Janela Resultante
Importação

PySimpleGUI
Declaração de
Janela Resultante
Importação

PySimpleGUIQt

PySimpleGUIWx

PySimpleGUIWeb

Portar código GUI de um framework para outro (por exemplo, mover seu código de tkinter para Qt)
geralmente requer uma reescrita de seu código. O PySimpleGUI foi projetado para permitir que
você facilite a movimentação entre as estruturas. Às vezes, algumas mudanças são exigidas de
você, mas o objetivo é ter um código altamente portátil com mudanças mínimas.

Alguns recursos, como o ícone da bandeja do sistema, não estão disponíveis em todas as
portas. O recurso Ícone da bandeja do sistema está disponível nas portas Qt e WxPython. Uma
versão simulada está disponível no tkinter. Não há suporte para um ícone da bandeja do sistema
na porta PySimpleGUIWeb.

Ambientes de tempo de execução

Ambiente Suportado
Pitão Python 3.4+
Sistemas
Windows, Linux, Mac
operacionais
PCs desktop, laptops, Raspberry Pi, dispositivos Android executando
Hardware
PyDroid3
Conectados repli.it, Trinket.com (ambos executam tkinter em um navegador)
Frameworks GUI tkinter, pyside2, WxPython, Remi

Integrações

Entre os mais de 200 "Programas de demonstração", você encontrará exemplos de como integrar
muitos pacotes Python populares em sua GUI.
Quer incorporar um desenho Matplotlib em sua janela? Não tem problema, copie o código demo e
instantaneamente tenha um desenho Matplotlib dos seus sonhos em sua GUI.

Esses pacotes e outros estão prontos para você colocar em sua GUI, pois há programas de
demonstração ou um repositório de demonstração disponível para cada um:
Pacote Descrição
Matplotlib Muitos tipos de gráficos e plotagens
OpenCV Visão computacional (frequentemente usada para IA)
VLC Reprodução de vídeo
pymunk Motor de física
psutil Estatísticas do ambiente do sistema
camarão API Reddit
PySimpleGUI envolve uma API especial para armazenar "Configurações do
json
usuário"
clima Integra-se com várias APIs de clima para fazer aplicativos de clima
mido Reprodução de MIDI
sopa linda Web Scraping (exemplo do observador de problemas do GitHub)

Instalando: floppy_disk:

Duas maneiras comuns de instalar o PySimpleGUI:

1.pip para instalar a partir do PyPI

2.Baixe o arquivo PySimpleGUI.py e coloque-o na pasta do seu aplicativo

Instalação e atualização do Pip

A forma atual sugerida de invocar o pip comando é executá-lo como um módulo usando
Python. Anteriormente, o comando pip ou pip3 estava diretamente em uma linha de comando /
shell. O caminho sugerido

Instalação inicial para Windows:

python -m pip install PySimpleGUI

Instalação inicial para Linux e MacOS:

python3 -m pip install PySimpleGUI

Para atualizar usando pip você simplesmente 2 parâmetros para a linha --upgrade --no-cache-dir .

Atualizar instalação no Windows:

python -m pip install --upgrade --no-cache-dir PySimpleGUI

Atualização para Linux e MacOS:

python3 -m pip install --upgrade --no-cache-dir PySimpleGUI

Instalação de arquivo único

O PySimpleGUI foi criado como um único arquivo .py para que seja muito fácil para você instalá-
lo, mesmo em sistemas que não estão conectados à internet como o Raspberry Pi. É tão simples
quanto colocar o arquivo PySimpleGUI.py na mesma pasta do aplicativo que o importa. Python
usará sua cópia local ao realizar a importação.

Ao instalar usando apenas o arquivo .py, você pode obtê-lo do PyPI ou, se quiser executar a
versão não lançada mais recente, faça o download no GitHub.

Para instalar a partir do PyPI, baixe o wheel ou o arquivo .gz e descompacte o arquivo. Se você
renomear o arquivo .whl para .zip, poderá abri-lo como qualquer arquivo zip normal. Você
encontrará o arquivo PySimpleGUI.py em uma das pastas. Copie este arquivo para a pasta do seu
aplicativo e pronto.

O link PyPI para a versão tkinter do PySimpleGUI é: https://pypi.org/project/PySimpleGUI/#files

A versão mais recente do repositório GitHub pode ser encontrada

aqui: https://raw.githubusercontent.com/PySimpleGUI/PySimpleGUI/master/PySimpleGUI.py

Agora alguns de vocês estão pensando, "sim, mas, espere, ter um único arquivo fonte enorme é
uma ideia terrível". E, sim, às vezes pode ser uma ideia terrível. Nesse caso, os benefícios
superaram em muito o lado negativo. Muitos conceitos em ciência da computação são
compensadores ou subjetivos. Por mais que alguns queiram que seja, nem tudo é preto e
branco. Muitas vezes a resposta a uma pergunta é "depende".

Galerias: arte:

O trabalho em uma galeria mais formal de GUIs enviadas pelo usuário, bem como aquelas
encontradas no GitHub, está em andamento, mas não está completo até o momento. Atualmente,
existem 2 lugares onde você pode ir para ver algumas capturas de tela de uma forma
centralizada. Esperançosamente, um Wiki ou outro mecanismo pode ser lançado em breve para
fazer justiça às incríveis criações que as pessoas estão fazendo.

Galeria enviada pelo usuário

O primeiro é um problema com as capturas de tela enviadas pelo usuário e localizadas no

GitHub. É uma forma informal de as pessoas mostrarem o que fizeram. Não é o ideal, mas foi um
começo.
Grandes imagens raspadas do GitHub

A segunda é uma galeria enorme com mais de 3.000 imagens obtidas de 1.000 projetos no GitHub
que supostamente usam o PySimpleGUI. Não foi filtrado manualmente e existem muitas imagens
antigas que foram usadas na documentação inicial. Mas, você pode encontrar algo lá que
desperte sua imaginação.

Usos para PySimpleGUI: martelo:

As seções a seguir mostram uma fração dos usos do PySimpleGUI. Existem mais de 1.000
projetos apenas no GitHub que usam o PySimpleGUI. É realmente incrível as possibilidades que
se abriram para tantas pessoas. Muitos usuários falaram sobre a tentativa anterior de criar uma
GUI em Python e falhar, mas finalmente alcançaram seus sonhos quando experimentaram o
PySimpleGUI.

Sua primeira GUI

É claro que um dos melhores usos do PySimpleGUI é fazer com que você crie GUIs para seus
projetos Python. Você pode começar tão pequeno quanto solicitar um nome de arquivo. Para isso,
basta fazer uma única chamada para uma das "funções de alto nível" chamadas popup . Existem
todos os tipos de pop-ups, alguns coletam informações.

popup mas ele próprio cria uma janela para exibir informações. Você pode passar vários
parâmetros como uma impressão. Se você deseja obter informações, então você vai chamar
funções que começam com popup_get_ tais como popup_get_filename .

Adicionar uma única linha para obter um nome de arquivo em vez de especificar um nome de
arquivo na linha de comando pode transformar seu programa em um que "pessoas normais" se
sintam confortáveis em usar.
importar PySimpleGUI como sg

filename = sg . popup_get_file ( 'Insira o arquivo que deseja processar' )

sg . pop-up ( 'Você inseriu' , nome do arquivo )

Este código exibirá 2 janelas pop-up. Um para obter o nome do arquivo, que pode ser navegado
ou colado na caixa de entrada.
A outra janela exibirá o que é coletado.

Janelas estilo Rainmeter

As configurações padrão para estruturas de GUI não tendem a produzir as janelas mais
bonitas. No entanto, com alguma atenção aos detalhes, você pode fazer várias coisas para tornar
as janelas mais atraentes. O PySimpleGUI facilita a manipulação de cores e recursos, como
remover a barra de título. O resultado são janelas que não se parecem com as janelas típicas do
tkinter.

Aqui está um exemplo de como você pode criar janelas que não se parecem com o seu tkinter
típico em janelas. Neste exemplo, as janelas têm suas barras de título removidas. O resultado são
janelas que se parecem muito com aquelas encontradas ao usar o Rainmeter, um programa de
widget para desktop.

Você também pode definir facilmente a transparência de uma janela. Aqui estão mais exemplos de
widgets de desktop no mesmo estilo Rainmeter. Alguns estão escurecidos por serem
semitransparentes.

Ambos os efeitos, removendo a barra de título e tornando uma janela semitransparente, são
obtidos definindo 2 parâmetros ao criar a janela. Este é um exemplo de como o PySimpleGUI
permite fácil acesso aos recursos. E como o código PySimpleGUI é portável nas estruturas GUI,
esses mesmos parâmetros funcionam para outras portas, como Qt.

Alterar a chamada de criação de Window no Exemplo 1 para esta linha de código produz uma
janela semitransparente semelhante:
janela = sg . Janela ( 'Minha janela' , layout , no_titlebar = True , alpha_channel = 0,5 )

Jogos

Embora não seja especificamente escrito como um SDK de desenvolvimento de jogos, o

PySimpleGUI torna o desenvolvimento de alguns jogos bastante fácil.

Este programa de xadrez não só joga xadrez, mas se integra com a IA de jogo de xadrez
Stockfish.
Diversas variantes do Campo Minado foram lançadas pelos usuários.

Os jogos de cartas funcionam bem com o PySimpleGUI, pois a manipulação de imagens é

simples ao usar o Graph elemento PySimpleGUI .

Embora não seja especificamente escrito como um SDK de desenvolvimento de jogos, o

PySimpleGUI torna o desenvolvimento de alguns jogos bastante fácil.
Captura e reprodução de mídia
Capturar e exibir vídeo de sua webcam em uma GUI são 4 linhas de código PySimpleGUI. Ainda
mais impressionante é que essas 4 linhas de código funcionam com as portas tkinter, Qt e
Web. Você pode exibir sua webcam, em tempo real, em um navegador usando o mesmo código
que exibe a imagem usando tkinter.

A reprodução de mídia, áudio e vídeo, também pode ser obtida usando o player VLC. Um
aplicativo de demonstração é fornecido a você para que você tenha um exemplo de trabalho para
começar. Tudo o que você vê neste leiame está disponível para você como um ponto de partida
para suas próprias criações.

Inteligência artificial
A IA e o Python são há muito tempo uma superpotência reconhecida quando os dois estão
emparelhados. O que geralmente falta, no entanto, é uma maneira de os usuários interagirem com
esses algoritmos de IA de maneira familiar, usando uma GUI.

Essas demos do YOLO são um ótimo exemplo de como uma GUI pode fazer uma enorme
diferença na interação com algoritmos de IA. Observe dois controles deslizantes na parte inferior
dessas janelas. Esses 2 controles deslizantes mudam alguns dos parâmetros usados pelo
algoritmo YOLO.
Se você estava ajustando sua demonstração YOLO usando apenas a linha de comando, você
precisaria definir os parâmetros, uma vez, ao iniciar o aplicativo, ver como eles funcionam, parar o
aplicativo, alterar os parâmetros e, finalmente, reiniciar o aplicativo com o novo parâmetros.

Compare essas etapas com o que pode ser feito usando uma GUI. Uma GUI permite que você
modifique esses parâmetros em tempo real. Você pode obter feedback imediatamente sobre como
eles estão afetando o algoritmo

Existem tantos programas de IA publicados que são controlados por linha de

comando. Isso em si não é um grande obstáculo, mas é um "pé no saco" digitar / colar o
nome do arquivo que deseja colorir na linha de comando, executar o programa e abrir o
arquivo de saída resultante em um visualizador de arquivos .
As GUIs têm o poder de mudar a experiência do usuário , para preencher a "lacuna da
GUI". Com este exemplo de colorizador, o usuário só precisa fornecer uma pasta cheia de
imagens e clicar em uma imagem para colorir e exibir o resultado.

O programa / algoritmo para fazer a colorização estava disponível gratuitamente, pronto para
uso. O que faltou é a facilidade de uso que uma GUI poderia trazer.

Gráficos
Exibir e interagir com dados em uma GUI é simples com o PySimpleGUI. Você tem várias opções.

Você pode usar os recursos de desenho / gráficos integrados para produzir gráficos
personalizados. Este monitor de uso de CPU usa o Graph elemento
Matplotlib é uma escolha popular entre usuários de Python. PySimpleGUI pode permitir que você
incorpore gráficos Matplotlib diretamente em sua janela GUI. Você pode até incorporar os
controles interativos em sua janela se quiser manter os recursos interativos do Matplotlib.

Usando os temas de cores do PySimpleGUI, você pode produzir gráficos um pouco acima dos
gráficos padrão que a maioria das pessoas cria no Matplotlib.

A "lacuna da GUI" mencionada anteriormente pode ser facilmente resolvida usando

PySimpleGUI. Você nem mesmo precisa ter o código-fonte do programa ao qual deseja adicionar
uma GUI. Uma GUI "front-end" é aquela que coleta informações que são então passadas para um
aplicativo de linha de comando.
GUIs front-end são uma maneira fantástica para um programador distribuir um aplicativo que os
usuários relutavam em usar anteriormente porque não se sentiam confortáveis usando uma
interface de linha de comando. Essas GUIs são sua única escolha para programas de linha de
comando para os quais você não tem acesso ao código-fonte.

Este exemplo é um front-end para um programa chamado "Jump Cutter". Os parâmetros são
coletados por meio da GUI, uma linha de comando é construída usando esses parâmetros e, em
seguida, o comando é executado com a saída do programa de linha de comando sendo roteada
para a interface GUI. Neste exemplo, você pode ver em amarelo o comando que foi executado.

Raspberry Pi

Como o PySimpleGUI é compatível com o Python 3.4, ele é capaz de criar uma GUI para seus
projetos Raspberry Pi. Funciona particularmente bem quando emparelhado com um ecrã
táctil. Você também pode usar o PySimpleGUIWeb para controlar seu Pi se ele não tiver um
monitor conectado.
Acesso fácil a recursos avançados
Como é muito fácil acessar muitos dos recursos subjacentes das estruturas GUI, é possível reunir
recursos para criar aplicativos que não se parecem em nada com aqueles produzidos usando a
estrutura GUI diretamente.

Por exemplo, não é possível alterar a cor / aparência de uma barra de título usando tkinter ou
outros pacotes de GUI, mas com PySimpleGUI é fácil criar janelas que aparecem como se
tivessem uma barra de título personalizada.
Inacreditavelmente, esta janela está usando o tkinter para conseguir o que parece ser algo como
um protetor de tela.

No Windows, o tkinter pode remover completamente o plano de fundo do seu aplicativo. Mais uma
vez, o PySimpleGUI torna o acesso a esses recursos trivial. A criação de uma janela transparente
requer a adição de um único parâmetro à chamada que cria o seu Window . Uma mudança de
parâmetro pode resultar em uma aplicação simples com este efeito:

Você pode interagir com tudo em sua área de trabalho, clicando em uma janela de tela inteira.

Temas
Cansado das GUIs cinza padrão? O PySimpleGUI torna trivial a aparência de sua janela ao fazer
uma única chamada para a theme função. Existem mais de 150 temas de cores diferentes
disponíveis para você escolher:
Com a maioria das estruturas GUI, você deve especificar a cor de cada widget que
criar. PySimpleGUI assume essa tarefa de você e irá colorir automaticamente os elementos para
combinar com o tema escolhido.

Para usar um tema, chame a theme função com o nome do tema antes de criar sua janela. Você
pode adicionar espaços para facilitar a leitura. Para definir o tema como "Dark Grey 9":

importar PySimpleGUI como sg

sg . tema ( 'cinza escuro 9' )

Esta única linha de código muda completamente a aparência da janela:

O tema mudou as cores do plano de fundo, texto, plano de fundo de entrada, texto de entrada e
cores dos botões. Em outros pacotes de GUI para alterar esquemas de cores como este, você
precisaria especificar as cores de cada widget individualmente, exigindo várias alterações em seu
código.