Interface gráfica com python

Prof. Sérgio Assunção Monteiro

Prof. Kleber de Aguiar

Descrição

Apresentação dos principais frameworks e das bibliotecas necessárias

para o desenvolvimento de aplicações de interface gráfica (GUI) no
python, como adicionar widgets para montar a interface gráfica, como
implementar uma interface para incluir dados em tabela e localizar,
alterar e excluir dados em tabela.

Propósito

Compreender como criar uma aplicação GUI em python que interaja

com um banco de dados, de modo a realizar as operações de inserção,
consulta, alteração e exclusão de dados em uma tabela.

Preparação

Antes de iniciar este conteúdo, você precisar ter instalado uma versão
do python, a IDE Spyder e o PostgreSQL.

Objetivos

Módulo 1

Frameworks e Bibliotecas para interface

gráfica
Identificar alguns dos principais frameworks e as bibliotecas
necessárias para a GUI

Módulo 2

Criação de aplicação GUI

Descrever a adição de widgets e montagem da interface gráfica

Módulo 3

Interação com banco de dados

Definir a interface para inclusão de dados em uma tabela no banco de

dados

Módulo 4

Interface gráfica e banco de dados

Identificar a interface para localização, alteração e exclusão de dados

em tabela

meeting_room
Introdução
Cada vez mais, nós geramos e consumimos dados para
realizarmos atividades que vão desde a abertura de uma conta
bancária até as informações que disponibilizamos nas redes
sociais.

Portanto, é necessário entender como esses dados são

gerenciados, pois são importantes para identificar pessoas,
preferências, produtos, transações financeiras, entre tantas
outras aplicações.
 Para fazer esse gerenciamento, as aplicações usam sistemas
gerenciadores de banco de dados a fim de realizar operações de
inserção, consulta, alteração e exclusão de dados.

Além disso, para que o usuário possa interagir de modo eficiente

com o sistema, é importante que ele tenha à disposição uma
interface gráfica que facilite o seu acesso às funcionalidades
implementadas.

A linguagem python aparece como uma opção muito eficaz para

atingir esses objetivos, uma vez que oferece recursos para
desenvolver aplicações que integrem interface gráfica com
operações no banco de dados.

Ao longo deste conteúdo, apresentaremos alguns dos principais

frameworks e as bibliotecas para desenvolver aplicações de
interface gráfica, além de explorarmos como realizar aplicações
no banco de dados.

1 - Frameworks e bibliotecas para interface gráfica

Ao final deste módulo, você será capaz de identificar alguns dos principais frameworks e as
bibliotecas necessárias para a GUI.

Frameworks e bibliotecas para GUI

Conceitos
A linguagem python possui muitos frameworks para desenvolvimento
de aplicações de interface gráfica para interação com o usuário,
chamadas, comumente, de GUI (Graphical User Interface).
O framework mais comum é o Tkinter (python interface to Tcl/Tk-2020)
que já faz parte da instalação python, mas existem outros frameworks
com características específicas que podem torná-los a escolha
adequada para um projeto.

Entre os frameworks para aplicações GUI mais comuns estão:

Tkinter
É o framework GUI padrão do python. Sua sintaxe é simples, possui
muitos componentes para interação com o usuário. Além disso, seu
código é aberto e é disponível sob a licença python. Caso ela não esteja
instalada na sua versão do python, basta digitar o comando:

Terminal
content_copy

1 pip install tkinter

Para quem usa a IDE Spyder (SPYDER, 2020), é necessário colocar uma
exclamação antes do comando “pip”, ou seja:

Terminal
content_copy

1 !pip install tkinter

Para testar a instalação, basta escrever o seguinte código na linha de

comando:

Python
content_copy

1 import tkinter
2 tkinter._test()

Se a instalação ocorreu normalmente, aparecerá uma tela com alguns

componentes para que você possa interagir e ter uma impressão inicial
do potencial desse framework:
 Exemplo de aplicação do Tkinter.

Atenção!
Devido à importância do Tkinter, vamos explorá-lo com bastantes
detalhes mais à frente.

Flexx
É um kit de ferramentas para o desenvolvimento de interfaces gráficas
com o usuário implementado em python que faz uso de tecnologia web
para sua renderização. O Flexx pode ser usado para criar tanto
aplicações de desktop como para web e até mesmo exportar uma
aplicação para um documento HTML independente. Para instalar o
Flexx, basta digitar o comando:

Terminal
content_copy

1 pip install flexx

Para quem usa a IDE Spyder, é necessário colocar uma exclamação

antes do comando “pip”, isso vale para qualquer instalação de
biblioteca/framework/pacote.

Comentário
Para evitar repetições sobre isso, apresentaremos aqui como instalar o
pacote Flexx na IDE Spyder, mas, para os próximos casos, mostraremos
apenas a instalação tradicional, ou seja, sem o símbolo de
“exclamação”.

No caso do Spyder, o comando deve ser:

Terminal
content_copy

1 !pip install flexx

Uma forma prática de testar a instalação e aprender um pouco mais
sobre esse framework é escrever o código abaixo na linha de comando,
ou em um arquivo, e executar:

Python
content_copy

1 from flexx import flx

2 class Exemplo(flx.Widget):
3
4 def init(self):
5 flx.Button(text='Olá')
6 flx.Button(text='Mundo')

Se a instalação estiver correta, a seguinte janela vai se abrir:

Exemplo de aplicação com Flexx.

CEF python
É um projeto de código aberto voltado para o desenvolvimento de
aplicações com integração ao Google Chrome. Existem muitos casos de
uso para CEF. Por exemplo, ele pode ser usado para criar uma GUI
baseada em HTML 5, pode usá-lo para testes automatizados, como
também pode ser usado para web scraping, entre outras aplicações.

Para instalá-lo, basta digitar na linha de comando:

Terminal
content_copy

1 pip install cefpython3

Para testar a instalação do CEF python, basta escrever o código abaixo

na linha de comando, ou em um arquivo, e executar:

Python
content_copy
 1 from cefpython3 import cefpython as cef
2 import platform
3 import sys
4 def main():
5 check_versions()
6 sys.excepthook = cef.ExceptHook # To shutdown a

Atenção!
Como esse exemplo, apesar de simples, é um pouco maior, cabe
lembrar que a indentação faz parte da sintaxe do python (python 3.8.5
documentation, 2020), por isso, é necessário ter bastante cuidado, caso
contrário o programa apresentará erros.

Se tudo funcionou corretamente, quando o programa executar, abrirá a

seguinte janela:

Exemplo de aplicação com CEF python.

Observe o título da janela: “Olá, mundo! Este é o primeiro

exemplo do CEF python”.

Kivy

É um framework python de código aberto para o desenvolvimento de

aplicações com interfaces de usuário e multitoque. Ele é escrito em
python e Cython, baseado em OpenGL ES 2, suporta vários dispositivos
de entrada e possui uma extensa biblioteca de componentes (widgets).

Com o mesmo código, a aplicação funciona para Windows, macOS,

Linux, Android e iOS. Todos os widgets Kivy são construídos com
suporte multitoque.

Para instalá-lo, é necessário escrever na linha de comando:

Terminal
content_copy

1 pip install Kivy

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 from kivy.app import App

2 from kivy.uix.button import Button
3
4 class ExemploApp(App):
5 def build(self):
6 return Button(text='Olá, Mundo!')

Se tudo funcionar corretamente, aparecerá a aplicação, conforme a

próxima imagem.

Exemplo de aplicação Kivy.

Na imagem anterior, é possível identificar o título da janela “Exemplo” e

um componente botão no centro da tela com a mensagem “Olá,
Mundo!”. Um ponto interessante pode ser observado no código, que é a
utilização da programação orientada a objetos.

Pyforms
É um framework python 3 para desenvolver aplicações que podem
operar nos ambientes Desktop GUI, Terminal e Web. A biblioteca é
composta por três sub-bibliotecas, cada uma implementando a camada
responsável por interpretar a aplicação Pyforms em cada ambiente
diferente:

1. Pyforms-gui.

2. Pyforms-web.

3. Pyforms-terminal.

Essas camadas podem ser usadas individualmente ou em conjunto,

dependendo da instalação do Pyforms. Para fazer a instalação básica, é
necessário escrever na linha de comando:

Python
content_copy

1 pip install pyforms

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 import pyforms
2 from pyforms.basewidget import BaseWidget
3 from pyforms.controls import ControlText
4 from pyforms.controls import ControlButton
5
6 class ExemploSimples(BaseWidget):

Se tudo funcionar corretamente, aparecerá a aplicação conforme a

imagem seguinte.

Exemplo de aplicação Pyform.

Comentário
No exemplo da imagem anterior, é possível ver três caixas de texto,
chamadas de “controle de texto”, e um componente botão, chamado de
“controle de botão” pelo Pyforms. Ele foi projetado a fim de desenvolver
aplicações para executar no modo Windows GUI.

PyQt
Uma aplicação desenvolvida no framework PyQt e executada nas
plataformas Windows, macOS, Linux, iOS e Android.

Trata-se de um framework que aborda, além de desenvolvimento GUI,

abstrações de sockets de rede, threads, Unicode, expressões regulares,
bancos de dados SQL, OpenGL, XML, entre outras aplicações.

Suas classes empregam um mecanismo de comunicação segura entre

objetos que é fracamente acoplada, tornando mais fácil criar
componentes de software reutilizáveis.

Para fazer a instalação básica, é necessário escrever na linha de

comando:

Terminal
content_copy
 1 pip install PyQt5

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 import sys
2 from PyQt5 import QtCore, QtWidgets
3 from PyQt5.QtWidgets import QMainWindow, QLabel, Q
4 from PyQt5.QtCore import QSize
5
6 class HelloWindow(QMainWindow):
7 def __init__(self):
8 QMainWindow.__init__(self)
9
10 self.setMinimumSize(QSize(280, 120))
11 self.setWindowTitle("Olá, Mundo! Exemplo PyQ
12
13 centralWidget = QWidget(self)
14 self.setCentralWidget(centralWidget)
15
16 gridLayout = QGridLayout(self)
17 centralWidget.setLayout(gridLayout)
18
19 title = QLabel("Olá Mundo para PyQt", self)
20 title.setAlignment(QtCore.Qt.AlignCenter)
21

Se tudo funcionar corretamente, aparecerá a aplicação conforme a

imagem a seguir.

Exemplo de aplicação PyQt.

No exemplo da imagem acima, é possível identificar uma janela, o título

da janela e uma mensagem ao centro.

wxPython
É um kit de ferramentas GUI baseadas em uma biblioteca C++ chamada
wxWidgets que foi lançada em 1998. O wxpython usa os componentes
(widgets) reais na plataforma nativa sempre que possível. Essa,
inclusive, é a principal diferença entre o wxpython e outros kits de
ferramentas, como PyQt ou Tkinter.

Atenção!
As aplicações desenvolvidas em wxpython se assemelham a aplicações
nativas do sistema operacional em que estão sendo executadas.

As bibliotecas PyQt e Tkinter têm componentes personalizados. Por isso

é bastante comum que as aplicações fiquem com um aspecto diferente
das nativas do sistema operacional. Apesar disso, o wxpython também
oferece suporte a componentes personalizados.

Para fazer a instalação básica, é necessário escrever na linha de

comando:

Terminal
content_copy

1 pip install wxpython

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 import wx
2 class Janela(wx.Frame):
3 def __init__(self, parent, title):
4 super(Janela, self).__init__(parent, title=t
5 self.panel = ExemploPainel(self)
6 self.text_ctrl = wx.TextCtrl(self.panel, pos
7 self.btn_test = wx.Button(self.panel, label=
8
9
10 class ExemploPainel(wx.Panel):
11 def __init__(self, parent):
12 super(ExemploPainel, self).__init__(parent)
13
14
15 class ExemploApp(wx.App):
16 def OnInit(self):
17 self.frame = Janela(parent=None, title="Jane
18 self.frame.Show()
19 return True
 20

Se tudo funcionar corretamente, aparecerá a aplicação, conforme a

imagem seguinte.

Exemplo de aplicação wxpython.

No exemplo da imagem anterior, é possível identificar uma janela, o seu

respectivo título, uma caixa de texto e um botão com a mensagem
“Pressione esse componente!”.

PyAutoGUI

Permite desenvolver aplicações python que controlem o mouse e o

teclado para automatizar as interações com outros aplicativos.

Comentário

Uma das situações em que essa característica pode ser muito

interessante é na implementação de testes que simulem a interação do
usuário com o sistema.

O PyAutoGUI funciona no Windows, macOS e Linux e é executado no

python.

Para fazer a instalação básica, é necessário escrever na linha de

comando:

Terminal
content_copy

1 !pip install PyAutoGUI

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 import pyautogui
2 screenWidth, screenHeight = pyautogui.size()
3 currentMouseX, currentMouseY = pyautogui.position()
 4 pyautogui.moveTo(100, 150)
5 pyautogui.click()
6 pyautogui click(100 200)

Nesse código, basicamente tem-se esta sequência de instruções:

check Obter o tamanho do monitor principal.

check Obter a posição XY do mouse.

check Mover o mouse para as coordenadas XY.

check Clicar com o mouse.

check Mover o mouse para as coordenadas XY e clicar

nelas.

check Mover o mouse 10 pixels para baixo de sua posição

atual.

check Clicar duas vezes com o mouse.

check Usar a função de interpolação/atenuação para

mover o mouse por 2 segundos com pausa de um
quarto de segundo entre cada tecla.

check Pressionar a tecla Esc.

 check Pressionar a tecla Shift e segurá-la.

check Pressionar a tecla de seta para a esquerda 4 vezes.

check Soltar a tecla Shift.

check Pressionar a combinação de teclas de atalho Ctrl-C.

check Mostrar uma caixa de alerta aparecer na tela e

pausar o programa até clicar em OK.

Atenção!
Antes de executar o código, cabe um alerta: Essa aplicação, apesar de
ser muito simples, vai interagir com o seu sistema.

Se tudo funcionar corretamente, aparecerá a aplicação conforme a

próxima imagem.

Exemplo de aplicação PyAutoGUI.

A imagem vista anteriormente aparecerá depois do “cursor do mouse”

se movimentar na tela e o “teclado” escrever a mensagem “Esta é a
mensagem para tela”.
As possibilidades de aplicações são muitas para o PyAutoGUI.

PySimpleGUI
Esse pacote foi lançado em 2018 e possui portabilidade com os
pacotes: Tkinter, PyQt, wxpython e Remi, portanto aumenta as
possibilidades de uso de componentes na programação.

Para fazer a instalação básica, é necessário escrever na linha de

comando:

Terminal
content_copy

1 pip install pysimplegui

Uma forma de testar a instalação é escrever e executar o programa:

Python
content_copy

1 import PySimpleGUI as sg
2
3 sg.theme('DarkAmber')
4
5 layout = [ [sg.Text('Texto na linha 1')],
6 [sg.Text('Entre com um texto na linha 2'), sg.Inp

Se tudo funcionar corretamente, aparecerá a aplicação conforme a

imagem a seguir.

Exemplo PySimpleGUI.

No exemplo da imagem anterior, é possível identificar uma janela, o seu

respectivo título, dois componentes “label”, uma caixa de texto e dois
botões.

Atenção!
A lista de frameworks e bibliotecas disponíveis para python ainda tem
muitos outros exemplos, como o PySide e o PyObject. A escolha deve
levar em consideração a maturidade da biblioteca/framework e a
necessidade de o projeto incorporar ou não aspectos mais elaborados
de uma GUI.

Interface GUI
Vantagens e desvantagens de uma Interface GUI
Agora, discutiremos sobre alguns dos aspectos do desenvolvimento de
um projeto de interface gráfica.

Vantagens

Entre as principais vantagens relacionadas às escolhas por uma

biblioteca/framework para um projeto da interface GUI, estão:

Facilidade de interação do usuário com o sistema por meio da

utilização de componentes intuitivos.

Simplicidade de utilizar os componentes em um programa.

Compatibilidade do componente com múltiplas plataformas.

Criação de uma camada de abstração para o programador sobre

detalhes da programação dos componentes.

Incorporação de aspectos que facilitem a experiência do usuário

com o sistema.

Facilidade para o usuário alternar rapidamente entre as

funcionalidades do sistema.

Bastante documentada e com uma comunidade engajada, o que

ajuda a perceber novas aplicações e evoluções dos componentes
que vão melhorar a aplicação dos componentes GUI no sistema.

Desvantagens

Também devem ser levadas em consideração as desvantagens

relacionadas às escolhas de bibliotecas/frameworks da interface GUI:

Alguns componentes de interface gráfica usam muitos recursos

computacionais, pois têm como objetivo ser amigáveis para o
usuário e não necessariamente fazer uso otimizado dos recursos.
Como consequência, podem tornar as aplicações muitos lentas
para plataformas de versões mais antigas.

O uso dos componentes na programação pode ser

excessivamente complexo, fazendo com que o desenvolvedor
tenha que desviar esforço do objetivo principal para se preocupar
com detalhes dos componentes GUI.
 As bibliotecas disponibilizam componentes, mas a aplicação deles
no sistema é responsabilidade do desenvolvedor. Além de se
preocupar com aspectos de programação, é necessário se
preocupar como esses componentes vão ser disponibilizados no
sistema, pois, caso contrário, algumas tarefas podem ser mais
demoradas devido a muitos níveis de interação para selecionar a
escolha desejada, como, por exemplo, o uso excessivo de menus e
submenus.

Os componentes precisam ter comportamentos previsíveis.

Comportamentos inesperados são potencialmente perigosos, pois
podem dar acesso não autorizado a partes do sistema, revelando,
assim, vulnerabilidades de segurança.

Sistemas baseados em componentes GUI requerem mais memória

RAM para serem executados.

Ainda sobre uso de recursos computacionais, sistemas baseados

em componentes GUI demandam por processamento.

Podem ter um comportamento distinto quando operam em

diferentes plataformas, tanto na parte visual como pela demanda
de recursos computacionais.

O tempo necessário para utilizar os componentes GUI no sistema

pode ser longo, em especial quando há necessidade de atender a
muitos requisitos de infraestrutura.

A curva de aprendizado para profissionais não experientes pode

ser proibitiva para o desenvolvimento de projetos de curto de
prazo.

video_library
Como criar uma aplicação com
interface gráfica
Aprenda a criar uma aplicação com interface gráfica. Veja a
apresentação do protótipo de sistema que será desenvolvido, os
frameworks a serem utilizados e a preparação do ambiente para
utilização.
Falta pouco para atingir seus objetivos.

Vamos praticar alguns conceitos?

Questão 1

A linguagem Python é muito usada em diversas aplicações devido à

simplicidade da sintaxe e por possuir muitos pacotes disponíveis
que podem ser instalados por meio do comando “pip install ”. Sobre
o comando “pip”, selecione a opção correta:

A Funciona como um gerenciador de dependências.

Independentemente do ambiente de
B desenvolvimento, o comando “pip” deve ser usado
da mesma forma.

O comando “pip” é o único meio de fazer a

C
instalação de pacotes no Python.

Por se tratar de um comando nativo do Python, não

D
é necessário se preocupar com a versão do “pip”.

O “pip” é o interpretador utilizado pelo Python para

E
gerar o executável.

Parabéns! A alternativa A está correta.

O comando “pip” é um dos gerenciadores de dependências do

Python. Ele facilita a instalação de pacotes, mas possui algumas
pequenas variações de acordo com o ambiente de
desenvolvimento. Por exemplo, no Spyder, o comando “pip” deve ser
precedido do símbolo de exclamação “!”.

Questão 2

A biblioteca Tkinter é considerada a biblioteca padrão do Python

para o desenvolvimento de interface gráfica. Em relação à
biblioteca Tkinter, selecione a opção correta:
 A biblioteca Tkinter sempre será a melhor escolha
A para um projeto de interface gráfica, pois é
compatível com múltiplas plataformas.

Seus componentes não se integram diretamente na

B linguagem Python, sendo necessário usar outros
programas para ter acesso aos seus recursos.

Seus componentes GUIs são considerados

C avançados e, portanto, apropriados para aplicações
de jogos, por exemplo.

A biblioteca Tkinter é a base para que todos os

D
outros frameworks GUI possam ser utilizados.

Para testar se ela está instalada corretamente, pode-

E se escrever duas linhas de código que são import
tkinter e tkinter._test().

Parabéns! A alternativa E está correta.

De fato, a biblioteca Tkinter é a mais importante do Python por estar

disponível na instalação padrão do Python, no entanto, apesar da
facilidade de aplicação, ela não é adequada para aplicações
específicas, como jogos.
2 - Criação de aplicação GUI
Ao final deste módulo, você será capaz de descrever a adição de widgets e montagem da
interface gráfica.

Biblioteca Tkinter
Conceitos
Neste módulo, o nosso foco será na criação de uma aplicação GUI. Para
isso, a biblioteca que vamos usar como referência é a Tkinter.

Comentário

Essa biblioteca GUI é considerada a padrão para desenvolvimento de

interface gráfica no python. Ela fornece uma interface orientada a
objetos que facilita a implementação de programas interativos.

Para usar o Tkinter – supondo que você já instalou o Pyhton e o pacote

Tkinter ‒, é necessário executar as seguintes etapas:

check Importar a biblioteca Tkinter.

check Criar a janela principal do programa GUI.

check Adicionar um ou mais dos widgets (componentes).

check Entrar no loop de evento principal para tratar os

eventos disparados pelo usuário.

O código fica assim:

Python
content_copy

1 import tkinter
2 janela = tkinter.Tk()
 3 janela.mainloop()

Esse programa produz a seguinte saída:

Exemplo de aplicação Tkinter.

Widgets Tkinter
O Tkinter possui diversos componentes (widgets), tais como botões,
rótulos e caixas de texto usados para criar aplicações interativas com o
usuário.

Os principais widgets do Tkinter, de acordo com Meier (2015), são:

É usado para exibir os botões na

aplicação. São usados, por exemplo,
Botão (Button)
para confirmar uma ação de salvar
os dados.

É usado para desenhar formas,

Telas (Canvas) como linhas, ovais, polígonos e
retângulos.

É usado para exibir várias opções

Botão de verificação como caixas de seleção. O usuário
(Checkbutton) pode selecionar várias opções ao
mesmo tempo.

É usado para exibir uma caixa de

Entrada de texto
texto de linha única para que o
(Entry)
usuário digite valores de entrada.

É usado como um widget de

contêiner, isso significa que outros
Quadros (Frame) componentes são adicionados a ele
com o objetivo de organizar outros
widgets.

Rótulo (Label) É usado para fornecer uma legenda

de linha única para outros widgets.
 Também pode conter imagens.

Caixa de listagem É usado para fornecer uma lista de

(Listbox) opções para um usuário.

Menubutton É usado para exibir opções no menu.

É usado para fornecer várias

possibilidades de comandos a um
Menu usuário.
Esses comandos estão contidos no
Menubutton.

É usado para exibir uma mensagem

Mensagem
de texto e um botão para o usuário
(Message)
confirmar uma ação/td>

É usado para exibir várias opções,

Botão de rádio como botões de rádio. O usuário
(Radiobutton) pode selecionar apenas uma opção
por vez.

É usado para fornecer um widget de

Escala (Scale)
controle deslizante.

Barra de rolagem É usado para adicionar capacidade

(Scrollbar) de rolagem a vários widgets.

É usado para exibir texto em várias

Texto (Text)
linhas.

É usado para fornecer um contêiner

Toplevel
de janela separado.

É uma variante do widget Entry

Spinbox padrão. Ele é usado para selecionar
um número fixo de valores.

É um widget de contêiner que pode

conter qualquer número de painéis,
PanedWindow
organizados horizontalmente ou
verticalmente.

É um widget de contêiner simples.

Seu objetivo principal é atuar como
LabelFrame
um espaçador, ou contêiner para
layouts de janela.

Este módulo é usado para exibir

tkMessageBox
caixas de mensagens.
Cada um desses widgets possuem propriedades que permitem
personalizar tamanhos, cores e fontes que serão exibidos para o
usuário.

Na próxima seção, apresentaremos alguns exemplos que vão ajudar a

entender como desenvolver uma aplicação GUI.

Exemplos de aplicações GUI

Desenvolvendo exemplos de apliaçãoes GUI
Recomendação
Antes de iniciar esta seção, é fortemente recomendado que você tenha
feito a instalação da versão mais atual do python e tente executar os
exemplos.

Vamos apresentar exemplos dos componentes:

1. Window

2. Label

3. Button

4. Entry

5. Radiobutton

6. Checkbox

7. Text

8. Message

9. Sliders

10. Dialog

11. Combobox

Widget Window (tk.Tk())

Para iniciar, a primeira aplicação vai exibir uma janela redimensionável,

conforme a imagem seguinte.
 Exemplo de uma janela redimensionável.

O código dessa aplicação é:

Python
content_copy

1 import tkinter as tk
2 janela = tk.Tk()
3 janela.title(" Aplicação GUI")
4 janela.mainloop()

Agora, cada uma das linhas será analisada.

Linha 1 - É feita a importação da biblioteca Tkinter.

Linha 2 - É criada uma instância da classe Tk no objeto “janela”.

Linha 3 - O método “title” é usado para definir um título que

aparece no topo da janela, no caso, “Aplicação GUI”.

Linha 4 - A aplicação inicia o loop de evento principal da janela.

A janela da aplicação anterior é redimensionável, ou seja, o usuário pode

alterar as dimensões da janela se ele clicar com o cursor do mouse na
janela e arrastá-la.

Para fixar o tamanho da janela, é necessário determinar essa

propriedade conforme o código seguinte:

Python
content_copy

1 import tkinter as tk
2 janela = tk.Tk()
3 janela.title(" Aplicação GUI NÃO Dimensionável")
4 janela.resizable(False, False)
5 janela.mainloop()

Atenção!
A principal diferença desse exemplo em relação ao anterior está na linha
4, onde a propriedade de redimensionar a janela é colocada como
“Falso”.

Widget Label

O próximo exemplo apresenta como usar o widget “Label”. O código

para gerar uma aplicação com o “Label” é dado por:

Python
content_copy
 1 import tkinter as tk
2 from tkinter import ttk
3 janela = tk.Tk()
4 janela.title(" Aplicação GUI com o Widget Label")
5 ttk.Label(janela, text="Componente Label" ).grid(col
6 janela.mainloop()

Na próxima imagem, é exibido o resultado da execução:

Exemplo do componente Label.

Na linha 5, é feito o posicionamento do componente

“label” na “janela” com o gerenciador de layout “grid”.

Widget Button
O próximo exemplo apresenta como usar o widget “Button”.

O código para gerar uma aplicação com o componente “Button” é dado

por:

Python
content_copy

1 import tkinter as tk
2 contador = 0
3 def contador_label(lblRotulo):
4 def funcao_contar():
5 global contador
6 contador = contador + 1
 7 lblRotulo.config(text=str(contador))
8 lblRotulo.after(1000, funcao_contar)
9 funcao_contar()
10 janela = tk.Tk()
11 janela.title("Contagem dos Segundos")
12 lblRotulo = tk.Label(janela, fg="green")
13 lblRotulo.pack()
14 contador_label(lblRotulo)
15 btnAcao = tk.Button(janela, text='Clique aqui para
16 btnAcao.pack()
17 janela.mainloop()
18

Este programa vai gerar uma janela com um contador de segundos –

que utiliza um componente “label” – e um componente botão com a
mensagem “Clique aqui para interromper a contagem”.

Na próxima imagem, é exibido o resultado da execução do programa.

Exemplo do componente botão.

As linhas mais importantes deste código são:

Linha 14 - Chamada para a função “contador_label”, função que faz

a contagem dos segundos e a atualização dos dados do
componente “label”.

Linha 15 - Criação de uma instância do componente “botão” com

uma mensagem, largura do componente e o estabelecimento de
um comportamento, no caso, fechar a janela, quando o usuário
pressionar o botão.

Widget Entry

Agora, vamos analisar o componente “entry”. Ele é uma das principais

formas de o usuário entrar com dados no sistema.

A seguir, é apresentado um exemplo de como usar esse componente:

Python
content_copy

1 import tkinter as tk
 2 def mostrar_nomes():
3 print("Nome: %s\nSobrenome: %s" % (e1.get(), e2.
4 janela = tk.Tk()
5 janela.title("Aplicação GUI com o Widget Entry")
6

O código produzirá uma janela com duas entradas de dados (widgets

entry), dois botões e dois componentes rótulos, conforme podemos ver
na imagem a seguir.

Exemplo do componente entry.

Os códigos que estamos apresentando estão evoluindo em termos de

aplicações práticas.

No caso do exemplo da imagem anterior, com poucas modificações,

pode ser aplicado para muitas situações reais.

Agora, analisaremos os principais aspectos do código.

Linha 2 - É implementada a função “mostrar_nomes”, que vai exibir

na linha de comando os nomes que estão escritos nas instâncias
“e1” e “e2” do componente “entry”.

Linha 8 e 9 - São feitas as instâncias “e1” e “e2” do componente

entry.

Linha 10 e 11 - “e1” e “e2” são posicionados na janela.

Linha 12 e 13 - São instanciados objetos do componente “botão”.

Em especial, na linha 13, a função “mostrar_nomes” é associada
ao comportamento do botão.

Widget Radiobutton

O próximo exemplo apresenta como usar o widget “Radiobutton”. O

código para gerar uma aplicação com esse componente é dado por:

Python
content_copy

1 import tkinter as tk
2 janela = tk.Tk()
3 v = tk.IntVar()
4 tk.Label(janela,text="""Escolha uma linguagem de pr
5 tk.Radiobutton(janela,text="python",padx = 25,varia
6 tk.Radiobutton(janela,text="C++",padx = 25,variable
O código produzirá uma janela com dois “botões de rádio” (widgets
radiobutton), conforme a imagem a seguir.

Exemplo do componente radiobutton.

Linha 4 - É instanciado um componente “label” com a

parametrização das propriedades “text”, “justify” e “padx” que
correspondem, respectivamente, ao texto, a como ele será
justificado e à largura em pixels do componente.

Linha 5 e 6 - São instanciados os componentes “radiobuttons”. A

propriedade “variable” recebe o valor “v”, indicando que o
componente será colocado na vertical.

Widget Checkbox
O próximo exemplo apresenta como usar o widget “checkbox”. O código
para gerar uma aplicação com esse componente é dado por:

Python
content_copy

1 import tkinter as tk
2 from tkinter import ttk
3 janela = tk.Tk()
4 def escolha_carreira():
5 print("Gerencial: %d,\nTécnica : %d" % (var1.get
6 ttk.Label(janela, text="Escolha sua vocação:").grid
7 var1 = tk.IntVar()
8 ttk.Checkbutton(janela, text="Gerencial", variable=
9 var2 = tk.IntVar()
10 ttk.Checkbutton(janela, text="Técnica", variable=va
11 ttk.Button(janela, text='Sair', command=janela.quit
12 ttk.Button(janela, text='Mostrar', command=escolha_
13 janela.mainloop()
O código produzirá uma janela com um “label”, dois “checkboxes” e dois
botões, conforme a Figura 16.

Exemplo do componente checkbox.

Agora, vamos analisar os principais aspectos do código.

Linha 4 - É implementada a função “escolha_carreira”, que exibirá

os valores dos objetos “var1” e “var2”, que estão relacionados aos
“checkboxes”.

Linhas 7 e 9 - São instanciados os objetos “var1” e “var2”, que

serão associados aos “checkboxes”. Quando um “checkbox” for
selecionado, o seu respectivo objetivo vai retornar valor 1; caso o
componente não seja selecionado, o valor do objeto será 0.

Linhas 8 e 10 - São instanciados objetos dos componentes

“checkboxes”, que são associados, respectivamente, às opções
Gerencial e Técnica.

Widget Text
O próximo exemplo apresenta como usar o widget “Text”. O código para
gerar uma aplicação com o componente “Text” é dado por:

Python
content_copy

1 import tkinter as tk
2 janela = tk.Tk()
3 T = tk.Text(janela, height=2, width=30)
4 T.pack()
5 T.insert(tk.END, "Este é um texto\ncom duas linhas\
6 tk.mainloop()

O código produzirá uma janela com um texto, conforme a imagem a

seguir.
 Exemplo do componente Text.

Agora, vamos analisar os principais aspectos do código.

Linha 3 - É feita uma instância do componente “Text”.

Linha 5 - É inserido um texto na instância do componente “text”,

que será exibido na tela. Observe que o texto é separado em duas
linhas com o uso do “\n”.

Widget Message
O próximo exemplo apresenta como usar o widget “Message”. O código
para gerar uma aplicação com o componente “Message” é dado por:

Python
content_copy

1 import tkinter as tk
2 janela = tk.Tk()
3 mensagem_para_usuario = "Esta é uma mensagem.\n(Pod
4 msg = tk.Message(janela, text = mensagem_para_usuar
5 msg.config(bg='lightgreen', font=('times', 24, 'ita
6 msg.pack()

O código produzirá uma janela com uma mensagem, conforme pode ser
visto na imagem seguinte.

Exemplo do componente Message.

Agora, vamos analisar os principais aspectos do código.

Linha 4 - É instanciado um componente “Message” com uma

mensagem para o usuário.

Linha 5 - O componente é configurado, determinando a cor do

“background” e detalhes sobre a fonte da mensagem.

Widget Slider
O próximo exemplo apresenta como usar o widget “Slider”. O código
para gerar uma aplicação com esse componente é dado por:

Python
content_copy

1 import tkinter as tk
 2 from tkinter import ttk
3 def mostrar_valores():
4 print (w1.get(), w2.get())
5 janela = tk.Tk()
6

O código produzirá uma janela com duas linhas deslizantes, conforme a

imagem a seguir.

Exemplo do componente Slider.

Agora, vamos analisar os principais aspectos do código.

Linha 6 e 8 - São instanciados componentes “sliders”.

Além disso, são determinadas as propriedades “from”, “to” e “orient”, que

são responsáveis, respectivamente, pelo espectro de escala
componente e pela orientação do componente na tela.

Widget Dialog

O próximo exemplo apresenta como usar o widget “Dialog”. O código

para gerar uma aplicação com o componente “Dialog” é dado por:

Python
content_copy

1 import tkinter as tk
2 from tkinter import messagebox as mb
3 def resposta():
4 mb.showerror("Resposta", "Desculpe, nenhuma resp
5 def verificacao():
6 if mb.askyesno('Verificar', 'Realmente quer sair

O código produzirá uma janela com dois botões, conforme a imagem a

seguir.
 Exemplo com dois componentes botões.

close

Resposta Sair

Caso o usuário pressione o botão “Resposta”, Caso o usuár

aparecerá uma janela com a mensagem “Desculpe, aparecerá um
nenhuma resposta disponível!”, conforme a figura. quer sair?”, c

close
Resposta No

Caso o usuário pressione o botão “Yes”, aparecerá Por outro lad

uma janela com a mensagem “Ainda não foi janela da ima
implementado”, conforme mostra a imagem. mensagem “A
mostrado na

Agora, vamos analisar os principais aspectos do código.

Linha 4, 6, 7 e 9 - São instanciados componentes “messageDialog”.

Esse exemplo é bastante interessante, pois, apesar de pouca

implementação, é possível que o usuário tenha bastante interação com
o sistema.

Widget Combobox
O próximo exemplo apresenta como usar o widget “Combobox”. O
código para gerar uma aplicação com esse componente é dado por:

Python
content_copy

1 import tkinter as tk
 2 from tkinter import ttk
3 # Criação de uma janela tkinter
4 janela = tk.Tk()
5 janela.title('Combobox')
6 janela.geometry('500x250')
7 # Componente Label
8 ttk.Label(janela, text = "Combobox Widget",backgrou
9 # Componente Label
10 ttk.Label(janela, text = "Selecione um mês :",font
11 # Componente Combobox
12 n = tk.StringVar()
13 escolha = ttk.Combobox(janela, width = 27, textvari
14 # Adição de itens no Combobox
15 escolha['values'] = (' Janeiro',' Fevereiro',' Març
16 escolha.grid(column = 1, row = 5)
17 escolha.current()
18 janela.mainloop()

O código produzirá uma janela com um “combobox”:

Exemplo do componente combobox.

Agora, vamos analisar os principais aspectos do código.

Linha 17 - É instanciado um componente “combobox”.

Linha 19 a 30 - Os meses do ano são atribuídos ao componente.

video_library
Projetando a interface gráfica
Agora, daremos continuidade e projetaremos a interface gráfica. Veja
como são carregados os widgets necessários para o funcionamento do
protótipo.
Falta pouco para atingir seus objetivos.

Vamos praticar alguns conceitos?

Questão 1

Considere o fragmento de código Python abaixo.

Python
content_copy

1 import tkinter
2 lacuna_I = lacuna_II.Tk()
3 lacuna_III.mainloop()

Para que o código seja compilado e executado corretamente, as

palavras lacuna_I, lacuna_II e lacuna_III devem ser substituídas,
respectivamente, por:

A tk, janela, tkinter

B raiz, tkinter, janela

C tkinter, raiz, janela

D raiz, tkinter e raiz

E tkinter, janela e raiz

Parabéns! A alternativa D está correta.

A Tkinter é considerada a biblioteca padrão de interface gráfica do

Python. Para que um programa que faz uso de seus componentes
possa rodar, é necessário importar a biblioteca, instanciar um
componente “window” que é a “raiz” da interface gráfica onde os
demais componentes serão adicionados e, por fim, fazer a
chamada (invocação) do método “mainloop”.

Questão 2

O Tkinter possui diversos componentes (widgets) que são úteis

para criar aplicações que vão facilitar a interação do usuário com o
sistema. Nesse sentido, selecione a opção que relaciona
corretamente o componente e sua respectiva funcionalidade.

Button: fornece para o usuário a possibilidade de

A
selecionar várias opções ao mesmo tempo.

Checkbutton: é usado para a confirmação de uma

B
ação.

C Entry: exibe uma mensagem de texto para o usuário.

Label: é usado para fornecer uma legenda para

D
outros componentes do projeto.

E Dialog: produz uma janela com um “combobox”.

Parabéns! A alternativa D está correta.

O componente “label” é muito útil para fornecer uma explicação a

respeito de uma funcionalidade do sistema, por exemplo, ele pode
acompanhar uma caixa de texto (widget entry) com a legenda
“nome”, que dá a entender para o usuário que ele precisa preencher
seu próprio nome.
 3 - Interação com banco de dados
Ao final deste módulo, você será capaz de definir a interface para inclusão de dados em uma
tabela no banco de dados.

Visão geral
Conceitos
O python possui muitas bibliotecas para interagir com diversos bancos
de dados. Aqui, o foco será a integração com o PostgreSQL. Isso porque
pode ser usado gratuitamente, possui bastante documentação
disponível on-line e pode ser aplicado para resolver problemas reais.

Para explicar como o python interage com o PostgreSQL, trabalharemos

na seguinte aplicação:

“Desenvolver um programa em que seja possível

realizar as operações CRUD para gerenciar uma
agenda telefônica que vai tratar de nomes e números
de telefones”.

CRUD
Acrônimo da expressão do idioma Inglês, Create (Criação), Read (Consulta),
Update (Atualização) e Delete (Destruição).

A ideia é desenvolvermos uma aplicação CRUD para que os usuários

possam interagir com o sistema para inserir, modificar, consultar e
excluir dados de uma agenda telefônica, e que essas operações fiquem
sob a responsabilidade do sistema gerenciador de banco de dados.
Dica

Inicialmente, é necessário ter o PostgreSQL instalado. Os exemplos

apresentados aqui foram implementados na versão 4.24 do PostgreSQL.

Sql
content_copy

1 CREATE TABLE public."AGENDA"

2 (
3 id integer NOT NULL,
4 nome text COLLATE pg_catalog."default" NOT NULL,
5 telefone char(12) COLLATE pg_catalog."default" NO
6 )
7 TABLESPACE pg_default;
8 ALTER TABLE public."AGENDA"
9 OWNER to postgres;

Para testar se a criação da tabela está correta, pode-se inserir um

registro da seguinte maneira:

Sql
content_copy

1 INSERT INTO public."AGENDA"( id, nome, telefone)

2 VALUES (1, 'teste 1', '02199999999');

Em seguida, fazemos uma consulta na tabela:

Sql
content_copy

1 SELECT * FROM public." AGENDA";

Se tudo funcionar corretamente, aparecerá a seguinte saída:

 Saída da consulta na tabela AGENDA

Agora, vamos estudar o pacote que será utilizado para que o python
possa interagir com o PostgreSQL: psycopg2.

Atenção!
O PostgreSQL pode ser integrado ao python usando o módulo psycopg2.
Trata-se de um adaptador de banco de dados PostgreSQL. O pacote
psycopg2 é simples, rápido e estável.

Para instalá-lo, basta digitar na linha de comando do python:

Terminal
content_copy

1 pip install psycopg2

Para interagir com o banco de dados PostgreSQL com o uso da

biblioteca psycopg2, primeiro é necessário criar um objeto Connection,
que representa o banco de dados, e, em seguida, pode-se criar um
objeto cursor que será bastante útil para executar todas as instruções
SQL. Isso será detalhado um pouco mais à frente.

Antes disso, vamos apresentar as principais APIs (rotinas de interface

de programação) da psycopg2:

PostgreSQL expand_more

psycopg2.connect (database = "NomeDoBancoDeDados", user =

"LoginDoUsuário", senha = "SenhaDoBancoDeDados", host =
"EndereçoDaAplicação", porta = "NúmeroDaPorta")

A conexão com o banco de dados PostgreSQL é feita com essa

API. O banco de dados retorna um objeto de conexão, se o banco
de dados for aberto com sucesso. Para aplicações que vão rodar
localmente, utiliza-se o endereço de localhost dado por
 127.0.0.1". A porta de comunicação padrão do PostgreSQL é a
"5432", mas esse valor pode ser mudado.

Criar um cursor expand_more

connection.cursor ()

Esta API cria um cursor que será usado ao longo da

programação para interagir com o banco de dados com python.

Executar uma instrução SQL expand_more

cursor.execute (sql [, parâmetros opcionais])

Esta rotina é aplicada para executar uma instrução SQL. A

instrução SQL pode ser parametrizada.

Por exemplo, seja o trecho de código:

Sql
content_copy

1 nomeDaTabela = 'tabelaExemplo'
2 cursor.execute(" insert into %s values (%%s, %%s)" %

O comando executará a instrução “insert” para inserir os valores 10 e 20

na tabela ‘tabelaExemplo’.

Executa um comando SQL expand_more

cursor.executemany (sql, sequência_de_parâmetros) Esta rotina

executa um comando SQL em todas as sequências de
parâmetros.

Por exemplo, seja o trecho de código:

Sql
content_copy

1 carros = (
2 (1, 'Celta', 35000),
 3 (2, 'Fusca', 30000),
4 (3, 'Fiat Uno', 32000)
5 )
6
7 con = psycopg2.connect(database='BancoExemplo', us
8 password='postgres')
9
10 cursor = con.cursor()
11
12 query = "INSERT INTO cars (id, nome, preco) VALUES
13 cursor.executemany(query, carros)
14

O trecho de código começa com uma lista de três carros, na qual cada
carro possui um código de identificação, um nome e um preço.

Em seguida, é feita uma conexão com o banco de dados

“BancoExemplo”.

Logo depois, é criado o cursor que será usado para realizar as

operações sobre o banco de dados.

Por fim, é executada a rotina “executemany”, sendo que ela recebe uma
query e uma lista de carros que serão inseridos no banco de dados.

cursor.callproc
('NomeDaFunção_Ou_NomeDoProcedimentoArmazenado',
[parâmetros IN e OUT,])
Esta rotina faz chamada para uma função ou um procedimento
armazenado do banco de dados. Os parâmetros IN e OUT
correspondem, respectivamente, aos parâmetros de entrada e
saída da função ou do procedimento armazenado e devem ser
separados por vírgulas.

cursor.rowcount
Este atributo retorna o número total de linhas do banco de dados
que foram modificadas, inseridas ou excluídas pela última
instrução de “execute“.

connection.commit()
Este método confirma a transação atual. É necessário que ele seja
chamado ao final de uma sequência de operações sql, pois, caso
contrário, tudo o que foi feito desde a última chamada até o
“commit” não será visível em outras conexões de banco de dados.

connection.rollback()
Este método reverte quaisquer mudanças no banco de dados
desde a última chamada até o “commit”.

connection.close()
Este método fecha a conexão com o banco de dados. Ele não
chama o “commit” automaticamente. Se a conexão com o banco
 de dados for fechada sem chamar o “commit” primeiro, as
alterações serão perdidas.

cursor.fetchone()
Este método busca a próxima linha de um conjunto de resultados
de consulta, retornando uma única sequência, ou nenhuma,
quando não há mais dados disponíveis.

cursor.fetchmany([size = cursor.arraysize])
Esta rotina busca o próximo conjunto de linhas de um resultado de
consulta, retornando uma lista. Uma lista vazia é retornada quando
não há mais linhas disponíveis. O método tenta buscar quantas
linhas forem indicadas pelo parâmetro “size”.

cursor.fetchall() Esta rotina busca todas as linhas (restantes) de

um resultado de consulta, retornando uma lista. Uma lista vazia é
retornada quando nenhuma linha está disponível.

Exemplo prático com psycopg2

Um exemplo completo
Agora, apresentaremos um exemplo completo de como usar o psycopg2
que abordará:

table_rows
Criação de uma tabela

post_add
Inserção de dados

highlight_alt
Seleção de dados

refresh
Atualização de dados

delete_sweep
Exclusão de dados

Agora, vamos aos exemplos que implementam as operações CRUD.

Criação de tabela
Este primeiro código mostra como criar uma tabela a partir do python. É
uma alternativa em relação a criar a tabela usando o PostgreSQL.

Sql
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = "postgres", user
3 print("Conexão com o Banco de Dados aberta com suces
4 cur = conn.cursor()
5 cur.execute('''CREATE TABLE Agenda(ID INT PRIMARY KE
6 print("Tabela criada com sucesso!")
7 conn.commit()
8 conn.close()

Depois de colocar o programa para executar, se tudo funcionar

corretamente, aparecerão as mensagens na tela:

Conexão com o Banco de Dados feita com Sucesso! Tabela criada com
sucesso!

Agora, vamos analisar o código.

Linha 1 - É feita a importação da biblioteca psycopg2.

Linha 2 - É feita a conexão com o banco de dados. Observe os

parâmetros da função “connect”, pois é necessário que você crie
um banco no PostgreSQL com usuário e senha, conforme escrito
na função.

Linha 3 - É exibida uma mensagem de sucesso para o usuário.

Linha 4 - É criado o cursor que vai permitir realizar operações no

banco de dados.

Linha 5 - Executa o comando SQL para criar a tabela “Agenda” com

os campos “ID”, “Nome” e “Telefone”.

Linha 9 - É exibida uma mensagem de criação da tabela com

sucesso.
 Linha 10 - É executada a função “commit” para confirmar a
execução das operações SQL.

Linha 11 - Por fim, é fechada a conexão com o banco de dados.

Inserção de dados na tabela

O exemplo desse código mostra como inserir um registro em uma
tabela a partir do python usando a biblioteca psycopg2.

O exemplo desse código mostra como inserir um registro em uma

tabela a partir do python usando a biblioteca psycopg2.

Sql
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = " postgres", user
3 print ("Conexão com o Banco de Dados aberta com suce
4 cur=conn.cursor()
5 cur.execute("""INSERT INTO public."AGENDA" ("id", "n
6 conn.commit()
7 print("Inserção realizada com sucesso!"); 8conn.clos

As mensagens que vão aparecer depois da execução do programa são:

Conexão com o Banco de Dados feita com Sucesso! Inserção realizada

com sucesso!

Vamos analisar o código.

Linha 1 a 4 - São realizadas as mesmas operações do exemplo

anterior: Importação da biblioteca “psycopg2”, abrir a conexão
com o banco de dados “postgres” e impressão da mensagem
“Conexão aberta com sucesso!”.

Linha 5 - É executado o comando SQL para inserir dados na tabela

AGENDA.No caso, o registro é formado pelos seguintes dados: O
campo “id” recebe o valor 1, o campo “nome” recebe o valor
‘Pessoa 1’ e, por fim, o campo “telefone” recebe o valor
‘02199999999’.
Essa linha tem mais algumas questões que merecem destaque: O
uso de aspas simples e duplas.
No caso do banco de dados PostgreSQL, o nome da tabela e dos
campos deve estar entre aspas duplas, por causa disso é que o
comando insert possui três aspas duplas logo no início e no final.
Sendo assim, muita atenção com isso, pois existem algumas
 variações conforme o sistema gerenciador de banco de dados
escolhido.

Linha 6 a 8 - Do mesmo modo como foi realizado no exemplo de

criação da tabela “Agenda”, são realizadas as seguintes
operações: “commit” das operações do banco de dados,
fechamento da conexão com o banco de dados, impressão na
linha de comando da mensagem “Inserção realizada com
sucesso!”.

Seleção de dados na tabela

Antes de descrever o exemplo de seleção de dados, já podemos

perceber algo em comum em todas as operações dos códigos para
trabalhar com banco de dados no início do código:

Importação da Abertura da conexão

biblioteca “psycopg2”. arrow_forward com o banco de dados
“postgres”.

postgres
Perceba que esse nome não é do sistema gerenciador de banco de dados, e
sim um nome que escolhemos. Poderia ser, por exemplo,
“banco_dados_teste”.

E no final do código:

“Commit” das Fechamento da

operações realizadas no conexão com o banco
banco de dados para de dados.
confirmar a execução arrow_forward
delas. Esse comando é
obrigatório.

Agora, vamos analisar o código que mostra como selecionar um registro

em uma tabela a partir da biblioteca psycopg2 do python.

Python
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = " postgres", user
3 print ("Conexão com o Banco de Dados aberta com suce
4 cur=conn.cursor()
5 cur.execute("""select * from public."AGENDA" where "
 6 registro=cur.fetchone()
7 print(registro) 8 conn.commit() 9 print("Seleção rea
8 conn.close()

Depois de colocar o programa para executar, se tudo funcionar

corretamente, aparecerão as mensagens na tela:

Conexão com o Banco de Dados feita com Sucesso!

(1, 'Pessoa 1', '02199999999 ')
Tabela criada com sucesso!

Vamos analisar os trechos mais importantes do código.

Linha 5 - É feita a consulta na tabela “Agenda” pelo registro com

“id” igual a 1, por meio do comando Select do SQL.

Linha 6 - É executado o método “fetchone” que recupera

exatamente um registro do “cursor” e atribui para a variável
“registro”.

Linha 7 - É impresso na linha de comando o resultado da consulta

armazenado na variável “registro”.

Atualização de dados na tabela

Este exemplo mostra como atualizar os registros de uma tabela a partir

do python.

Python
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = " postgres", use
3 print ("Conexão com o Banco de Dados aberta com suc
4 cur=conn.cursor()
5 print("Consulta antes da atualização")
6 cur.execute("""select * from public."AGENDA" where
7 registro=cur.fetchone()
8 print(registro)
9 #Atualização de um único registro
10 cur.execute("""Update public."AGENDA" set "telefone
11 conn.commit()
12 print("Registro Atualizado com sucesso! ")
13 cur = conn.cursor()
14 print(" Consulta depois da atualização")
15 cur.execute("""select * from public."AGENDA" where
16 registro=cur.fetchone()
17 print(registro)
 18 conn.commit()
19 print("Seleção realizada com sucesso!");
20 conn.close()

Este código possui três partes distintas, que são:

Parte 1
Uma consulta antes da atualização que mostra os dados do registro
antes de serem modificados.

Parte 2
A atualização do registro que vai modificar os dados.

Parte 3
Uma consulta depois da atualização do registro que mostra como
ficaram os dados do registro depois de serem atualizados.

Atenção!
A linha 10 é a mais importante deste código. É nela que é executado o
comando “update” do sql, que atualizará o dado do campo “telefone” do
registro, cujo campo “id” contenha o valor “1”.

Perceba, ainda, que é associado o comando “commit” para o comando

“update” do sql na linha 11.

Exclusão de dados na tabela

Por fim, vamos ver o exemplo para excluir um registro de uma tabela.

Python
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = " postgres", use
3 print ("Conexão com o Banco de Dados aberta com suc
4 cur=conn.cursor()
5 cur.execute("""Delete from public."AGENDA" where "i
6 conn.commit()
7 cont=cur.rowcount
8 print(cont, "Registro excluído com sucesso!")
9 print("Exclusão realizada com sucesso!");
10 conn.close()
Depois de colocar o programa para executar, se tudo funcionar
corretamente, aparecerão as mensagens na tela:

Conexão com o Banco de Dados aberta com Sucesso!

1 Registro excluído com sucesso!Exclusão realizada
com sucesso!

Vamos analisar as partes mais importantes do código.

Linha 5 - É feita a consulta na tabela “Agenda” pelo registro com

“id” igual a 1, por meio do comando Select do SQL.É executado o
comando “delete” do sql que excluirá o registro cujo campo “id”
seja igual a “1”.

Linha 7 - A propriedade “rowcount” do “cursor” retorna a

quantidade de registros que foram excluídos da tabela “Agenda”.

Linha 8 - É impresso na linha de comando o total de registros que

foram excluídos.
Saiba mais
Além da biblioteca psycopg2, existem outras bibliotecas para trabalhar
com vários sistemas gerenciadores de banco de dados. Por exemplo:

- pyMySQL: Biblioteca que faz interface com o MySQL.

- cx_Oracle: Biblioteca que faz interface com o Oracle.
- PySqlite: Biblioteca que faz interface com o SQLite.
- PyMongo: Biblioteca que faz interface com o mongodb, que é um
banco de dados NoSQL.

video_library
Protótipo do sistema
Dando continuidade ao desenvolvimento do protótipo do sistema, veja a
modelagem do banco de dados a ser utilizado, criando o banco e
fazendo as inserções/atualizações/remoções necessárias.

Falta pouco para atingir seus objetivos.

Vamos praticar alguns conceitos?

Questão 1

Considere o fragmento de código Python abaixo que utiliza a

biblioteca “psycopg2” para fazer operações no sistema gerenciador
de banco de dados Postgre:

Python
content_copy

1 import psycopg2
2 conn = psycopg2.connect(database = "postgres",
3 cursor = conn.cursor()
4 cursor.execute("""lacuna_I INTO public."AGENDA"
5 conn. lacuna_II()
6 print("Inserção realizada com sucesso!");

Para que o código seja compilado e executado corretamente, as

palavras lacuna_I, lacuna_II e lacuna_III devem ser substituídas,
respectivamente, por:

A UPDATE, connect, close

B INSERT, fetchone, finally

C INSERT, commit, close

D INSERT, cursor e close

E UPDATE, commit, close

Parabéns! A alternativa C está correta.

A palavra-chave “INTO” está relacionada ao comando “INSERT” do

sql. Após a execução de um comando sql, é necessário confirmá-lo
mediante o comando “commit”. No final da execução de um
programa, deve-se fechar a conexão com o banco de dados com o
comando “close”.

Questão 2
Existem muitas bibliotecas disponíveis para Python para fazer
interface com sistemas gerenciadores de bancos de dados. Entre
elas, está a “psycopg2”. Essa biblioteca faz interface com o
PostgreSQL, que é um sistema importante para desenvolver
aplicações reais. Nesse sentido, selecione a opção que relaciona B
às APIs do psycopg2 e suas funcionalidades.

cursor.rowcount: Indica se o comando sql –

A
inserção, ou exclusão - foi executado com sucesso.

connection.commit(): Abre a conexão com o banco

B
de dados.

cursor.execute: É aplicada para executar uma

C
instrução SQL.

connection.close(): Limpa as variáveis que estão

D
associadas a operações com o banco de dados.

cursor.execute: Fecha a conexão com o banco de

E
dados.

Parabéns! A alternativa C está correta.

O comando “execute” é fundamental para executar as instruções do

sql para fazer inserção, consulta, atualização e exclusão de
registros no banco de dados.
4 - Interface gráfica e banco de dados
Ao final deste módulo, você será capaz de identificar a interface para localização, alteração e
exclusão de dados em tabela.

Visão geral
Conceitos
Até o dado momento, vimos como criar uma aplicação com
componentes de interface gráfica e como interagir com um banco de
dados.

Neste módulo, criaremos uma aplicação que integra tanto elementos de

interface gráfica quanto operações com banco de dados.

A nossa aplicação implementa as operações CRUD, que

são: inserção, seleção, atualização e exclusão de dados.

O usuário fará a entrada de dados mediante componentes de caixas de

texto (widget entry) e confirmará a ação que deseja quando pressionar o
botão correspondente.

Além disso, os dados que estão armazenados no banco são exibidos

em um componente do tipo grade (widget treeview). O usuário tem a
possibilidade de selecionar um registro na grade, o qual será exibido nas
caixas de texto, onde poderá ser modificado ou excluído.

Observe a interface gráfica da nossa aplicação:

Interface da aplicação com Tkinter.

Atenção!

Perceba que alguns dados já estão armazenados no banco e são

exibidos na grade. Veja que o usuário selecionou o “produto_7” na grade
e seus dados estão exibidos nas caixas de texto.

Criação de tabelas e geração de

dados
Criação de tabelas no Postgresql
A primeira ação a ser feita é a criação da tabela.

Comentário
No caso do nosso sistema, vamos criar a tabela Produto, que tem três
campos: “CODIGO”, “NOME” e “PRECO”.

Estamos usando o PostgreSQL para gerenciar nossos dados. O

PostgreSQL é um sistema gerenciador de banco de dados de licença
gratuita e é considerado bastante robusto para aplicações de um modo
geral.

Com a ferramenta pgAdmin, o desenvolvedor pode criar a tabela

produto.

Veja como criar uma tabela no pgAdmin:

Criação de tabela no pgAdmin.

O campo “owner” é o usuário proprietário do banco de

dados que terá acesso à tabela “PRODUTO”. No caso,
usamos o usuário padrão do PostgreSQL.

Em seguida, precisamos criar os campos tabelas. Para isso,

selecionamos a opção “Columns” da imagem anterior. Será exibida a
tela da imagem seguinte, na qual podemos adicionar as colunas por
meio da opção “+” no canto superior direito da tela.

Criação dos campos da tabela no pgAdmin.

 Perceba que o campo “CODIGO” é a chave primária da
tabela e, além disso, todos os campos não podem ser
vazios.

Agora, salvamos a tabela e, finalmente, ela é criada no banco de dados.

Na imagem a seguir, podemos ver a tabela no pgAdmin.

Visualização da tabela no pgAdmin.

O pgAdmin é bastante útil para fazermos operações sobre as tabelas.

Na imagem seguinte, mostramos como inserir dados na tabela
“PRODUTO”.

Inserção de dados no pgAdmin.

Para executar o comando de inserção, basta pressionar a seta no canto

direito superior da tela.

Outra forma de criar uma tabela é mediante o próprio python, com o uso
da biblioteca “psycopg2”.

Na próxima imagem, mostramos o código para criação da tabela

“PRODUTO”. O código para criação da tabela pode ser baixado clicando
aqui.

Criação de tabela no python.

Agora, as principais linhas serão analisadas.

 Linha 8 - Importamos a biblioteca psycopg2.

Linha 9 - Fazemos a conexão ao banco de dados “postgres” com o

usuário “postgres”, senha “senha123”, host local (127.0.0.1) e
porta “5432”.

Linha 13 - Abrimos o cursor. Lembre-se de que é com o cursor que

fazemos as operações no banco de dados.

Linha 14 a 16 - Executamos o comando sql “Create Table” para

criar a tabela “PRODUTO” com os campos “CODIGO”, “NOME” e
“PRECO”.

Linha 18 - Executamos o comando “commit” para confirmar o

comando sql.

Linha 19 - Fechamos a conexão com o banco de dados.

Geração de dados aleatórios

Uma boa forma de iniciar o projeto é inserindo dados aleatórios na
tabela. Para isso, vamos usar o pacote “faker”, que é bastante útil para
gerar dados aleatórios.

Na imagem a seguir, mostramos o código para gerar os dados

aleatórios.

Geração de dados aleatórios.

Linha 15 - Importamos a biblioteca “faker”.

Linha 22 - Instanciamos um objeto para gerar dados aleatórios no

“português do Brasil”.

Linha 25 a 31 - Geramos os dados aleatórios que serão inseridos

na tabela.

Linha 34 e 35 - Montamos o comando sql. Mas nesse momento,

trata-se apenas de um texto (string) que deve seguir uma sintaxe
cuidadosa: três aspas duplas no início e no final do texto. Além
disso, perceba os “%s” no trecho do “VALUES” que serão usados
para entrar com os dados das variáveis.

Linha 36 - Criamos um registro com as variáveis que serão

armazenadas na tabela.

Linha 37 - Aplicamos o comando “execute”, que executa o

comando sql com a entrada de dados que definimos na variável
registro.
Comentário
Esse exemplo é simples, mas ilustra testes que podem ser feitos logo no
começo do projeto que são úteis para validar a entrada de dados, além
de ser útil para os desenvolvedores aprenderem mais sobre o próprio
sistema.

Interação entre o sistema e o banco

de dados
Interação com o banco de dados
Nesta seção, apresentaremos a parte do sistema responsável pelas
operações CRUD.

O sistema foi desenvolvido usando programação orientada a objetos. O

arquivo do programa foi salvo com o nome “crud.py”.

A classe com os métodos para realizar as operações para interagir com

o banco de dados é a “AppBD”, conforme podemos ver na próxima
imagem.

Classe para operações CRUD.

Antes de continuar, lembre-se de que a indentação

(espaçamento) faz parte da sintaxe do python.

Linha 12 - Declaramos a classe “AppBD”.

Linha 13 - Implementamos o construtor da classe, que é o método

que é chamado logo que um objeto da classe AppBD for
instanciado.

Linha 16 a 25 - Implementamos o método para abrir a conexão.

Perceba as cláusulas “try” e “except”. Isso é fundamental para criar
um programa confiável, ou seja, com tolerância a falhas, pois o
programa tenta seguir o fluxo normal de execução, ou seja, abrir a
conexão com o banco de dados.
Comentário

Caso ocorra algum problema, ao invés de o programa interromper a

execução e exibir uma mensagem de erro, revelando vulnerabilidades do
sistema que podem ser exploradas por um atacante, ele vai exibir uma
mensagem amigável para o usuário, no caso, será “Falha ao se conectar
ao Banco de Dados”.

O próximo método é o que faz consulta no banco de dados:

Seleção de dados.

Vamos destacar os principais pontos do método “selecionarDados”.

Linha 35 - Montamos a instrução de consulta do sql.

Linha 38 - Executamos a instrução sql.

Linha 39 - Recuperamos as linhas que retornaram da consulta sql.

Linha 52 - Retornamos os registros para quem faz a chamada para

o método “selecionarDados”.

Agora, vamos explicar o método para fazer a inserção de dados. O

código do método está na imagem a seguir.

Inserção de dados.

Linha 56 - Implementamos a função “inserirDados” e passamos

como parâmetros os “codigo”, “nome” e “preco” que serão
inseridos na tabela. Além disso, passamos o parâmetro “self”, que
é usado para fazer referência aos atributos e métodos da própria
classe.

Linha 60 e 61 - Montamos a instrução sql para fazer a inserção

dos dados.

Linha 62 - Montamos o registro que será inserido na tabela.

Linha 63 - Executamos a instrução sql para fazer a inserção do

registro da variável “record_to_insert”.

Agora, vamos analisar o método responsável pela atualização de dados.

O código é apresentado na imagem seguinte.
 Atualização dos dados.

Linha 80 - Implementamos a função “atualizarDados” e passamos

como parâmetros os “codigo”, “nome” e “preco” que serão
modificados na tabela.

Linha 92 e 93 - Montamos a instrução sql para fazer a modificação

dos dados da tabela.

Linha 94 - Executamos a instrução sql para fazer a modificação do

registro de acordo com a tupla “(nome, preco, codigo)”.

Agora, vamos analisar o método que trata da exclusão de dados. O

código é apresentado na imagem a seguir.

Exclusão de dados.

Linha 116 - Implementamos a função “excluirDados” e passamos o

“codigo” do produto que será excluído da tabela.

Linha 121 e 122 - Montamos a instrução sql para fazer a exclusão

dos dados da tabela.

Linha 123 - Executamos a instrução sql para fazer a exclusão do

registro de acordo com o parâmetro “codigo” passado para o
método.

GUI: Interação com o usuário

Interface gráfica
Nesta seção, vamos apresentar a parte do sistema responsável pela
interação com o usuário por meio de uma interface gráfica.
 Do mesmo modo que a classe “AppBD”, esse programa
também foi desenvolvido em programação orientada a
objetos.

O arquivo do programa foi salvo com o nome “aplicacaoCRUD.py”. A

classe com os atributos e métodos para trabalhar com a interface
gráfica e interagir com a classe responsável pelas operações com o
banco de dados é a “PrincipalBD”, conforme podemos ver na imagem a
seguir.

Classe principal.

Linha 9 - Importamos a biblioteca Tkinter para interagir com os

componentes gráficos.

Linha 10 - Importamos o módulo ttk para podermos trabalhar com

o componente “TreeView”, que foi usado como uma grade para
exibir os dados armazenados na tabela “PRODUTO”.

Linha 14 - Implementamos o construtor ( __init__ ) da classe

PrincipalBD, que será chamado logo que um objeto do tipo
PrincipalBD for instanciado.

Linha 17 a 23 - Instanciamos os componentes rótulos (“label”) e

caixas de texto (“entry”).

Linha 24 a 27 - Instanciamos os componentes botões (“button”),

que vão acionar as operações CRUD.
Atenção!

Observe que os métodos “fCadastrarProduto”, “fAtualizarProduto”,

“fExcluirProduto” e “fLimparProduto” estão vinculados aos botões, ou
seja, quando o usuário pressionar um botão, o respectivo método será
chamado.

O construtor ainda possui mais duas partes. Uma delas é responsável

por instanciar e configurar o componente “TreeView”, conforme
podemos ver na próxima imagem.
 Configuração do componente Treeview.

Observe nas linhas 52 e 53 que o método

“apresentarRegistrosSelecionados” é vinculado à
instância do componente “TreeView”. Esse método
será explicado mais à frente.

E a outra posiciona os componentes na tela, conforme podemos ver na

imagem seguinte.

Configuração de componentes.

Observe que, na linha 73, fazemos chamada para o

método “carregarDadosIniciais”. Mais à frente, vamos
explicá-lo com mais detalhes.

Agora, vamos analisar o método “apresentarRegistrosSelecionados”,

conforme podemos ver na imagem seguinte.

Exibir dados selecionados no Treeview.

Este método exibe os dados selecionados na grade (componente

“TreeView”) nas caixas de texto, de modo que o usuário possa fazer
alterações, ou exclusões sobre eles.

Linha 76 - Fazemos a chamada para a função “fLimparTela”, que

limpa o conteúdo das caixas de texto.
 Linha 77 - Obtemos os registros que foram selecionados na grade
de registros.

Linha 79 - Os dados do item selecionados são, agora, associados

às variáveis “codigo”, “nome” e “preco”.

Linha 80 a 82 - Os valores das variáveis são associados às caixas

de texto.

Agora, vamos analisar o método “carregarDadosIniciais”, que é

apresentado na imagem a seguir.

Carregar dados da tabela no Treeview.

Este método carrega os dados que já estão

armazenados na tabela para serem exibidos na grade
de dados (componente “TreeView”).

Linha 86 e 87 - Os atributos “id” e “iid” são iniciados com valor 0.

Eles são necessários para gerenciar o componente “TreeView”.

Linha 88 - É feita a chamada para o método “selecionarDados” que

está na classe “AppBD”. Ele recupera todos os registros
armazenados na tabela.

Linha 91 e 93 - Obtemos os valores dos registros e associamos às

respectivas variáveis.

Linha 98 a 102 - Os dados são adicionados ao componente

“TreeView”.

Agora, vamos apresentar o método “fLerCampos”, conforme podemos

ver na imagem abaixo.

Entrada de dados.

Este método lê os dados que estão nas caixas de texto e os retorna para
quem faz a chamada.
Por exemplo, na linha 114, a variável “codigo” recebe o valor da caixa de
texto “txtCodigo” depois que ele é convertido para um valor do tipo
“inteiro”.

Na linha 123, as variáveis “codigo”, “nome” e “preco” retornam para quem

faz a chamada do método.

Agora, vamos apresentar o método “fCadastrarProduto”, conforme

podemos ver na imagem a seguir.

Inserção de dados no banco.

Este método tem como objetivo fazer a inserção dos dados na tabela
“PRODUTOS”.

Linha 130 - Os dados digitados nas caixas de texto são

recuperados nas variáveis “codigo”, “nome” e “preco”.

Linha 131 - Fazemos a chamada ao método “inserirDados”, que

fará a inserção dos dados na tabela “PRODUTO”.

Linha 132 a 136 - Os dados são inseridos no componente grade

(“TreeView”).

Agora, vamos analisar o método “fAtualizarProduto”, conforme podemos

ver na próxima imagem.

Atualização de dados no banco.

O objetivo deste método é atualizar os dados que o usuário

selecionou na grade de dados (o componente “TreeView”).

Linha 149 - Os dados selecionados da grade de dados são

recuperados nas variáveis “codigo”, “nome” e “preco”.

Linha 150 - Chamamos a função “atualizarDados”, que fará as

modificações dos dados na tabela “PRODUTO”.
 Linha 152 - Os dados selecionados são removidos da grade de
dados.

Linha 153 - Fazemos a chamada ao método

“carregarDadosIniciais” para recarregar a grade de dados com os
dados da tabela.

Agora, vamos analisar o método “fExcluirProduto”, conforme podemos

ver na imagem seguinte.

Exclusão de dados no banco.

O objetivo deste método é excluir os dados que o usuário selecionou na

grade de dados (o componente “TreeView”).

Linha 164 - Os dados selecionados da grade de dados são

recuperados nas variáveis “codigo”, “nome” e “preco”.

Linha 165 - Chamamos a função “excluirDados”, que excluirá os

dados da tabela “PRODUTO”.

Linha 167 - Os dados selecionados são removidos da grade de

dados.

Linha 168 - Fazemos a chamada ao método

“carregarDadosIniciais” para recarregar a grade de dados com os
dados da tabela.

Agora, vamos analisar o método “fLimparTela”, conforme podemos ver

na imagem a seguir.

Limpar os componentes da tela.

Este método limpa o conteúdo das caixas de texto,

conforme podemos ver nas linhas 179 a 181.
Por fim, apresentamos o programa principal que vai iniciar a execução
do sistema, conforme podemos ver na próxima imagem.

Programa principal.

Linha 188 - Instanciamos o objeto raiz da aplicação gráfica que

chamamos de “janela”.

Linha 189 - Instanciamos o objeto principal que vai gerenciar a

execução da aplicação.

Linha 190 - Escrevemos uma mensagem para o título da janela.

Linha 192 - Configuramos as dimensões da janela.

Linha 192 - Chamamos o método “mainloop”, que coloca a

aplicação para executar até que o usuário interrompa a execução.

video_library
Finalização da construção do
protótipo
Acompanhe a finalização da construção do protótipo do sistema
utilizando a linguagem python, uma interface GUI e a conexão ao banco
de dados.

Falta pouco para atingir seus objetivos.

Vamos praticar alguns conceitos?

Questão 1
Considere o fragmento de código Python abaixo que utiliza a
biblioteca “psycopg2” para fazer CRIAR a tabela PRODUTOv2 no
PostgreSQL:

Python
content_copy

1 import psycopg2
2 lacuna_I
3 conn = psycopg2.connect(database = "postgres",
4 print("Conexão com o Banco de Dados aberta com
5 cur = conn.cursor()
6 cur.execute('''CREATE TABLE PRODUTOv2
7 (CODIGO INT PRIMARY KEY NOT NULL,
8 NOME TEXT NOT NULL,
9 PRECO CHAR(12));''')
10 print("Tabela criada com sucesso!")
11 lacuna_II
12 conn.commit()
13 conn.close()

Selecione a opção correta, para que o programa execute

corretamente:

As palavras lacuna_I e lacuna_II devem ser

A substituídas por “#” (símbolo de comentário), pois
não afetam a execução do programa.

O tipo campo “PRECO” deve ser modificado para

B “REAL NOT NULL”, caso contrário vai ocorrer um erro
na criação da tabela.

As palavras lacuna_I e lacuna_II devem ser

substituídas por “try:” e “except (Exception,
C
psycopg2.Error) as error:” para prevenir a ocorrência
de exceções.

A tabela deve ser renomeada para “PRODUTO”, ao

D
invés de “PRODUTOv2”.

As palavras lacuna_I e lacuna_II devem ser

E substituídas por “Begin”, para marcar o início do
programa, e “End”, para indicar o fim do trecho sql.
 Parabéns! A alternativa C está correta.

Apesar de não serem obrigatórias, as cláusulas “try-except”

previnem a ocorrência de exceções, evitando que o programa seja
interrompido abruptamente caso ocorra algum problema.

Questão 2

Durante a execução de um programa em Python podem ocorrer

problemas que, se não forem tratados adequadamente, vão
interromper o programa e exibir uma mensagem de erro para o
usuário sem nenhum tipo de tratamento. Nesse sentido, selecione a
opção que apresenta a forma adequada de tratar exceções no
Python:

A if-else

B try-except

C if-elif

D try-catch

E if-else

Parabéns! A alternativa B está correta.

A cláusula “try” tenta executar o fluxo normal do programa. Caso

ocorra algum problema, a cláusula “except” permite tratar a exceção
e exibir uma mensagem amigável para o usuário sem a interrupção
do programa. O Python não obriga o uso das cláusulas “try-except”,
mas trata-se de uma boa prática de programação.

Considerações finais
No decorrer do texto, apresentamos os principais frameworks e as
bibliotecas para desenvolver aplicações de interface gráfica, exploramos
a biblioteca “tkinter” com exemplos para usar os seus componentes
gráficos e também a biblioteca “psycopg2”, para realizar operações no
PostgreSQL, além de apresentarmos uma aplicação que relaciona
interface gráfica com operações no banco de dados.

A linguagem python facilita bastante o desenvolvimento de aplicações

de interface gráfica e que façam operações no banco de dados. É
natural que o desenvolvedor iniciante tenha a impressão de que é um
projeto complexo, mas, com um pouco de prática, as vantagens de
programar nesse ambiente vão ficar evidentes.

O python é uma linguagem muito bem documentada e possui uma

comunidade engajada em resolver problemas e disponibilizar as
soluções em ambientes públicos. Exploramos algumas bibliotecas, mas
existem muitas outras. A escolha de uma delas deve levar em
consideração questões como tempo para desenvolvimento, maturidade
do programador e quais os recursos computacionais que se têm à
disposição.

headset
Podcast
Ouça agora sobre o processo de desenvolvimento de interfaces gráficas
com a linguagem Python.

Referências
MEIER, B. A. python GUI Programming Cookbook. Birmingham, United
Kingdom: Packt Publishing Ltd., 2015.

python. python 3.8.5 documentation. python.org. Publicado em 20 jul.

2020.
python. Tkinter ‒ python interface to Tcl/Tk. docs.python.org.
Consultado em 23 out. 2020.

SPYDER. The Scientific python Development Environment. [s.d.] spyder-

ide.org. Consultado em 23 out. 2020.

Explore +
Para saber mais sobre os assuntos tratados neste tema, pesquise na
internet:

- Os sites oficiais do tkinter e do psycopg2 e aprenda mais detalhes

técnicos sobre aplicações GUI e de banco de dados, além de poder fazer
downloads.
- Os sites oficiais das bibliotecas/frameworks/pacotes Kivy, Pyforms,
PyQt, wxpython, PyAutoGUI e PySimpleGUI para obter mais informações
sobre aplicações GUI no python.
- Os sites oficiais das bibliotecas/frameworks/pacotes pyMySQL,
cx_Oracle, PySqlite e PyMongo para obter mais informações sobre
aplicações de banco de dados no python.