UNIVERSIDADE METODISTA UNIDA DE MOÇAMBIQUE

CAMPUS UNIVERSITÁRIO DE CAMBINE

FACULDADE DE ENGENHARIA

Milton Carlos Isastro General

Licenciatura em Engenharia Informática e Tecnologias

Programação II

Interfaces Gráficas e Conexão Com Base de dados

UMUM

Cambine, Março de 2022

Conteúdo

Introdução........................................................................................3

Interfaces gráficas..............................................................................4

Tkinter............................................................................................4

event handler....................................................................................8

Recebimento de dados do usuário............................................................9

Conexão com Base de Dados.................................................................10

Conexão com SQLite...........................................................................11

Conclusão.......................................................................................13

Bibliografia......................................................................................14

Apêndices.......................................................................................15
Introdução

A facilidade de utilização em aplicações e a segurança, tanto web assim como

desktop são características que devem ser muito levadas em consideração no
momento da sua criação. Isto nos remete a ideia de interfaces boitas e intuitivas e
uma conexão segura com a base de dados.

O presente trabalho tem por objectivo trazer um estudo da criação de interfaces

gráfica na linguagem Python e a conexão com a base de dados de modo a prover
uma troca de informações da base de dados com a aplicação.
Interfaces gráficas

A Interface Gráfica do Usuário, ou GUI , como é mais conhecida, é um dos três

pilares principais de qualquer aplicativo , sendo os outros dois a segurança e o
desempenho . Manter o equilíbrio certo entre esses três aspectos vitais pode ajudá-
lo a garantir uma experiência de usuário intuitiva e perfeita. Não podemos
enfatizar o suficiente como é importante ter uma interface de usuário minimalista
e, ao mesmo tempo, robusta. Já se foram os dias em que os desenvolvedores
começavam a perder a cabeça para criar aquela interface de usuário perfeita na
ausência de ferramentas poderosas como frameworks.

Uma Interface Gráfica de Usuário (GUI)  é a primeira coisa que seu usuário vê e

com a qual interage quando abre seu aplicativo ou site. Ter uma boa GUI ajuda
muito a aumentar a reputação e a contagem de usuários da sua plataforma. Uma
interface de usuário geralmente inclui uma série de elementos visuais, como
ícones, botões, gráficos, texto exibido e várias outras formas de entrada, como
caixa de selecção, caixas de entrada de texto e outros.

É a combinação de todos esses elementos que compõe uma parte vital da

experiência do usuário do seu aplicativo ou site. A entrada para esses elementos
visuais pode ser dos meios usuais, como teclados, mouses e telas sensíveis ao
toque.

Em Python As Interfaces Gráficas com Usuário se popularizaram no

ambiente desktop, devido à facilidade de uso e a produtividade. Existem hoje
muitas bibliotecas disponíveis para a construção de aplicações GUI, tais como:
GTK+, QT, PyQt5, TK e wxWidgets.

Tkinter

Tkinter é uma biblioteca da linguagem Python que acompanha a instalação padrão

e permite desenvolver interfaces gráficas. Isso significa que qualquer computador
que tenha o interpretador Python instalado é capaz de criar interfaces gráficas
usando o Tkinter, com excepção de algumas distribuições Linux, exigindo que seja
feita o download do módulo separadamente. Esta é uma biblioteca nativa da
linguagem, bastando importá-lo no momento de uso e sempre estará disponível.

A instalação padrão do Python acompanha além do interpretador, um ambiente de

desenvolvimento, o IDLE, que está incluso no pacote Python na maioria das
versões, com excepção de algumas distribuições Linux.

Para importar o conteúdo do módulo usamos o seguinte comando:

From Tkinter import*

As interfaces podem conter diversos tipos de controlos (objectos utilizados para

interagir com o usuário ou para apresentar informações) e containers  (objectos
que servem de repositório para colecções de outros objectos).

Na maior parte do tempo, a interface gráfica espera por eventos e responde de

acordo. Os eventos podem ser resultado da interacção do usuário, como cliques e
arrastar de mouse ou digitação, ou ainda de eventos de sistema, como o relógio da
máquina. A reacção a um evento qualquer é definida através de funções callback 
(funções que são passadas como argumento para outras rotinas).

Controles mais usados:

 Rótulo (label): retângulo que exibe texto.

 Caixa de texto (text box): área de edição de texto.

 Botão (button): área que pode ser ativada interativamente.

 Botão de rádio (radio button): tipo especial de botão, com o qual são
formados grupos aonde apenas um pode ser apertado de cada vez.

 Botão de verificação (check button): botão que pode ser marcado e

desmarcado.

 Barras de rolagem (scroll bars): controles deslizantes horizontais ou

verticais, usados para intervalos de valores numéricos.

 Botão giratório (spin button): caixa de texto com dois botões com setas ao
lado que incrementam e decrementam o número na caixa.
  Barra de status (status bar): barra para exibição de mensagens, geralmente
na parte inferior da janela.

 Imagem (image): área para exibição de imagens.

Controles podem ter aceleradores (teclas de atalho) associados a eles.

Containers mais usados:

 Barra de menu (menu bar): sistema de menus, geralmente na parte superior

da janela.

 Fixo (fixed): os objectos permanecem fixos nas mesmas posições.

 Tabela (table): colecção de compartimentos para fixar os objectos,

distribuídos em linhas e colunas.

 Caixa horizontal (horizontal box): semelhante à tabela, porém apenas com

uma linha.

 Caixa vertical (vertical box): semelhante à tabela, porém apenas com uma
coluna.

 Caderno (notebook): várias áreas que podem ser visualizadas uma de cada
vez quando selecionadas através de abas, geralmente na parte superior.

 Barra de ferramentas (toolbar): área com botões para acesso rápido aos
principais recursos do aplicativo.

Para lidar com eventos de tempo, as interfaces gráficas implementam um recurso

chamado temporizador (timer) que evoca a função callback depois de um certo
tempo programado.

Aqui vai um exemplo

import tkinter

class Application:

def __init__(self, master=None):

pass

root = Tk()
Application(root)

root.mainloop()

O código acima gerou como saída a seguinte tela.

Primeiro importamos todos os componentes do módulo Tkinter. Logo após,

criamos uma classe chamada Application, que no momento ainda não possui
nenhuma informação. É nela que criaremos os controlos que serão exibidos na tela.

Depois instanciamos a classe TK ()  através da variável root, que foi criada no final
do código. Essa classe permite que os widgets possam ser utilizados na aplicação.

Em Application (root)  passamos a variável root como parâmetro do método

construtor da classe Application. E para finalizar, chamamos o
método root.mainloop() para exibirmos a tela. Sem o event loop, a interface não
será exibida.

O módulo Tkinter oferece três formas de trabalharmos com geometria e

posicionamento:

1. Pack;

2. Grid;

3. Place.

Exemplo:
class Application:
def __init__(self, master=None):
self.widget1 = Frame(master)
 self.widget1.pack()
self.msg = Label(self.widget1, text="Primeiro widget")
self.msg["font"] = ("Verdana", "10", "italic", "bold")
self.msg.pack ()
self.sair = Button(self.widget1)
self.sair["text"] = "Sair"
self.sair["font"] = ("Calibri", "10")
self.sair["width"] = 5
self.sair["command"] = self.widget1.quit
self.sair.pack ()

root = Tk()
Application(root)
root.mainloop()
Saída:

event handler

Os event handlers são acções que executadas como resposta a determinado evento.
Sempre que um evento ocorre, o event loop o interpreta como uma string. Por
exemplo, ao clicar com o botão esquerdo do mouse, o event loop interpreta esta
ação pela string "": o botão ENTER é representado pela string "" e o botão direito do
mouse pela string "".

from tkinter import *

class Application:
def __init__(self, master=None):
self.widget1 = Frame(master)
self.widget1.pack()
self.msg = Label(self.widget1, text="Primeiro widget")
self.msg["font"] = ("Calibri", "9", "italic")
self.msg.pack ()
self.sair = Button(self.widget1)
self.sair["text"] = "Clique aqui"
self.sair["font"] = ("Calibri", "9")
 self.sair["width"] = 10
self.sair["command"] = self.mudarTexto
self.sair.pack ()

def mudarTexto(self):
if self.msg["text"] == "Primeiro widget":
self.msg["text"] = "O botão recebeu um clique"
else:
self.msg["text"] = "Primeiro widget"
root = Tk()
Application(root)
root.mainloop()
Quando executamos este código e o botão que foi criado recebe um clique, o texto
é modificado na tela, graças ao event handler associado ao bind, como mostra
a figura.

Recebimento de dados do usuário

Para receber dados do usuário vamos usar o widget Entry, onde os mesmos são
capturados como string, de forma semelhante ao método input.

Vide o exemplo no apêndice em 1

Conexão com Base de Dados

Com o Python podemos escrever scripts que se conectam a bancos de dados

relacionais, permitindo realizar operações diversas como as operações CRUD
básicas (Create, Read, Update, Delete) ou a execução de declarações SQL diversas
e procedimentos armazenados, triggers, funções e outros tipos de rotinas.

Geralmente, os SGBDs utilizam a arquitetura cliente-servidor. Os aplicativos usam a

API cliente para poder se comunicar com o servidor, que é o responsável por
receber as consultas dos clientes, interpretar as sentenças SQL e recuperar os
dados com um tempo de resposta adequado. Para fazer isso, o servidor precisa
realizar uma série de outras tarefas, tais como: verificar credenciais, controlar o
acesso, gerenciar conexões de rede, manter a integridade dos dados, optimizar as
consultas e resolver questões de concorrência.

No Python, a integração com SGBDs é feita na maioria dos casos através de um

módulo DBI., que usa a API cliente para se comunicar com o banco de dados.
Database Interface (DBI) é uma especificação que descreve como deve ser o
comportamento de um módulo de acesso a sistemas de banco de dados.

A DBI define que o módulo deve ter uma função connect(), retorna objetos de
conexão. A partir do do objeto conexão, é possível obter um objeto cursor, que
permite a execução de sentenças SQL e a recuperação dos dados (uma lista de
tuplas com os resultados, por default).

Para instalar o DBI para comunicar a aplicação Python e a base de dados MySQL
usamos o comando: pip3 install mysql-conector-python

Aqui vai um código para conexão do python com mysql batabase

import mysql.connector

con =
mysql.connector.connect(host='localhost',database='lwand',user='root',password='12
3**')

if con.is_connected():

db_info = con.get_server_info()

print("Conectado ao servidor MySQL versão ",db_info)

cursor = con.cursor()

cursor.execute("select database();")

linha = cursor.fetchone()

print("Conectado ao banco de dados ",linha)

if con.is_connected():

cursor.close()

con.close()

print("Conexão ao MySQL foi encerrada")

Conexão com SQLite

No exemplo usaremos o SQLite, que já vem incorporado ao módulo DBI. Então

podemos acessá-lo sem necessidade de instalar módulos externos. O SQLite cria um
arquivo com extensão .db em disco, contendo todas as tabelas da aplicação.

class Banco():

def __init__(self):

self.conexao = sqlite3.connect('banco.db')

self.createTable()

def createTable(self):

c = self.conexao.cursor()
c.execute("""create table if not exists usuarios (

idusuario integer primary key autoincrement ,

nome text,

telefone text,

email text,

usuario text,

senha text)""")

self.conexao.commit()

c.close()
Conclusão

Chegados aqui, podemos concluir que Python tem um grande número de

frameworks de GUI (ou kits de ferramentas) disponíveis para ele, desde TkInter 
(tradicionalmente empacotado com Python, usando Tk) até uma série de outras
soluções de plataforma cruzada, bem como ligações para plataformas específicas
(também conhecidas como " tecnologias nativas").

No Python, a integração de uma aplicação com SGBDs é feita na maioria dos casos
através de um módulo DBI., que usa a API cliente para se comunicar com o banco
de dados. A DBI define que o módulo deve ter uma função connect(), retorna
objectos de conexão. A partir do objecto conexão, é possível obter um objecto
cursor, que permite a execução de sentenças SQL e a recuperação dos dados (uma
lista de tuplas com os resultados, por padrão).
Bibliografia

Borges, L (2010). Python para desenvolvedores.2ed, Edição do Autor: Rio de

Janeiro disponível em:
https://ark4n.files.wordpress.com/2010/01/python_para_desenvolvedores_2ed.pd
f/

Devmedia (2016). Tkinter: Interfaces gráficas em Python. Disponível em:

https://www.devmedia.com.br/tkinter-interfaces-graficas-em-python/33956/

https://wiki.python.org/moin/GuiProgramming/

https://mayararysia.medium.com/python-conex%C3%A3o-com-o-mysql-
d919bb596702/
Apêndices

Apêndice 1 código de recebimento de dados do usuário

from tkinter import *

class Application:

def __init__(self, master=None):

self.fontePadrao = ("Arial", "10")

self.primeiroContainer = Frame(master)

self.primeiroContainer["pady"] = 10

self.primeiroContainer.pack()

self.segundoContainer = Frame(master)

self.segundoContainer["padx"] = 20

self.segundoContainer.pack()

self.terceiroContainer = Frame(master)

self.terceiroContainer["padx"] = 20

self.terceiroContainer.pack()

self.quartoContainer = Frame(master)

self.quartoContainer["pady"] = 20

self.quartoContainer.pack()

self.titulo = Label(self.primeiroContainer, text="Dados do usuário")

self.titulo["font"] = ("Arial", "10", "bold")

self.titulo.pack()

self.nomeLabel = Label(self.segundoContainer,text="Nome",
font=self.fontePadrao)

self.nomeLabel.pack(side=LEFT)

self.nome = Entry(self.segundoContainer)
 self.nome["width"] = 30

self.nome["font"] = self.fontePadrao

self.nome.pack(side=LEFT)

self.senhaLabel = Label(self.terceiroContainer, text="Senha",

font=self.fontePadrao)

self.senhaLabel.pack(side=LEFT)

self.senha = Entry(self.terceiroContainer)

self.senha["width"] = 30

self.senha["font"] = self.fontePadrao

self.senha["show"] = "*"

self.senha.pack(side=LEFT)

self.autenticar = Button(self.quartoContainer)

self.autenticar["text"] = "Autenticar"

self.autenticar["font"] = ("Calibri", "8")

self.autenticar["width"] = 12

self.autenticar["command"] = self.verificaSenha

self.autenticar.pack()

self.mensagem = Label(self.quartoContainer, text="",

font=self.fontePadrao)

self.mensagem.pack()

#Método verificar senha

def verificaSenha(self):

usuario = self.nome.get()

senha = self.senha.get()

if usuario == "usuariodevmedia" and senha == "dev":

self.mensagem["text"] = "Autenticado"

else:

self.mensagem["text"] = "Erro na autenticação"

root = Tk()

Application(root)

root.mainloop()

Saída: