Sumário

Capítulo 1 - Introdução a Python ....................................................................................................... 4

1 - História ......................................................................................................................................... 4
2 – Características principais da linguagem ................................................................................... 4
3 - O que é uma IDE e qual utilizar? ............................................................................................... 6
VISUAL STUDIO........................................................................................................................... 6
PYCHARM ..................................................................................................................................... 6
VISUAL STUDIO CODE ............................................................................................................... 7
IDE ESCOLHIDA........................................................................................................................... 7
4 - Processo de download e instalação da linguagem e da IDE - Baixando o Visual Studio Code
............................................................................................................................................................. 7
Capítulo 2 – Apresentando a programação em Python ................................................................... 13
1 – Exercícios Resolvidos, entendendo na pratica. ....................................................................... 13
1.0 – Dando os primeiros passos ................................................................................................ 13
1.1 – Calcular área do triângulo. ............................................................................................... 15
1.2 – Calcular o seno e o cosseno do ângulo. ............................................................................. 17
1.3 – Calcular a média de notas. ................................................................................................ 18
1.4 – Realizando uma equação simples. ..................................................................................... 20
1.5 – Realizando uma equação simples em switch-case. .......................................................... 21
1.6 – Utilizando for, criar a tabuada de um número. ............................................................... 22
1.7 – Utilizando for, exibir os “n” primeiros termos da série: 2, 5, 10, 17, 26........................ 23
1.8 – Utilizando while, listar os termos da série de Fibonacci (1, 1, 2, 3, 5, 8, 13, 21 ...)
menores que 1000. ....................................................................................................................... 24
1.9 – Utilizando while, entrar com dois valores via teclado, onde o segundo deverá ser maior
que o primeiro ............................................................................................................................. 25
1.10 – Utilizando while, entrar via teclado com o sexo de determinado usuário, aceitando
somente “F” ou “M” como respostas válidas. ........................................................................... 25
1.11 – Misturando laços, calcular e exibir o fatorial de um número ...................................... 26
1.12 – Utilizando vetor, exibir os valores digitados em tela na ordem inversa à da digitação.
....................................................................................................................................................... 28
1.13 – Utilizando vetor, criar um laço capaz de calcular a somatória de 10 valores e então
exibir a média desses valores. ..................................................................................................... 29

2
 1.14 – Utilizando vetor, criar um laço capaz de identificar o maior e o menor dos números
digitados e exibi-los. .................................................................................................................... 30
1.15 – Utilizando matriz, pesquisa e informar a idade do sujeito informando seu nome. .... 31
1.16 – Utilizando matriz, criar um sistema para automatizar a reserva de assento em um
cinema........................................................................................................................................... 33
Capítulo 3 – Apresentando a interface gráfica ................................................................................. 36
1 – O que é PyQt5 e como ele funciona? ....................................................................................... 36
2 – Instalando e conhecendo o PyQt5 ............................................................................................ 37
3 – Criando programas em modo gráfico ..................................................................................... 48
1° Programa: Aplicação que calcula o seno e o cosseno de um ângulo. ................................. 48
2° Programa: Aplicação que calcula a média e verificação da situação do usuário.............. 56
3° Programa: Criando uma calculadora ................................................................................... 62
Capítulo 4 – Exemplos de programas com a interface gráfica ........................................................ 67
1 – Calcular a área do triângulo .................................................................................................... 67
2 – Calcular Salário Horista ........................................................................................................... 73
3 – Equação de Segundo Grau ....................................................................................................... 76
4 – Cadastro livro ............................................................................................................................ 89
Capítulo 5 – Ligando My Sql ao Python ........................................................................................... 95
1 – Acesso ao banco de dados ......................................................................................................... 95
2 – Construindo a lógica ................................................................................................................. 96
2.1 – Classe IMH.......................................................................................................................... 96
2.2 – Classe BLL ........................................................................................................................ 101
2.3 – Classe DAL........................................................................................................................ 103
Capítulo 6 – Aplicando Firebase Google no Python ...................................................................... 105
1 - CLASSE DAL....................................................................................................................... 105
2 - CLASSE IMH....................................................................................................................... 107
3 - CLASSE BLL ....................................................................................................................... 110
Referências ......................................................................................................................................... 113

3
 Capítulo 1 - Introdução a Python

1 - História

A linguagem Python foi criada nos anos 80, por Guido Van Hossum. O desenvolvedor
da linguagem ABC trabalhava, no Instituto de Pesquisa Nacional para Matemática e Ciência da
Computação (CWI), em um sistema operacional chamado AMOEBA.
Ao criar a linguagem Python, Guido pretendia desenvolver uma linguagem intuitiva e
de fácil compreensão, uma vez que a linguagem C se mostrava complexa no desenvolvimento
de determinados softwares e era necessário a ajuda de programadores experientes para
compreender certos programas.
O nome da linguagem foi inspirado no programa Monty Python’s Flying Circus, o
programa favorito de Van Hossum.
A serpente píton só foi associada à linguagem no primeiro livro de programação em
Python, produzido pela editora O’Reilly. A editora tem o costume de colocar um animal na
capa de seus livros e escolheu a serpente píton para fazer parte da capa da linguagem Python.

2 – Características principais da linguagem

Python é uma linguagem de programação imperativa, interpretada e de alto nível com

tipagem forte e dinâmica. É considerada a linguagem de múltiplos paradigmas, pois aceita
diferentes formas de programação. Características funcionais principais de Python são: lambda
(função sem nome); map (aplica uma função a cada item de uma lista); reduce (faz um
somatório de uma lista); filter: (aplica uma condição em cada item da lista); zip (agrupa
elementos entre listas).
Um dos principais recursos do Python é sua notação especial. E leia o código de acordo.
Lá não existem separadores convencionais, que consistem em chaves e são usados, por
exemplo, em linguagens como C, C ++, C # e Java. O ponto-e-vírgula usado como final de um
comando nas linguagens, é opcional em Python. Apenas essas duas funções distinguem
claramente o Python dos outros em termos de legibilidade e fonte. Outro recurso interessante
do Python é que qualquer pessoa pode estendê-lo facilmente. As extensões de suporte podem
ser escritas em qualquer idioma. As extensões podem adicionar funções, variáveis e tipos de
objetos ao interpretador Python. Isso, junto com sua funcionalidade e implantação de código

4
aberto, justifica sua escolha por muitas organizações governamentais. É preferível que eles não
usem tecnologia proprietária sobre a qual não tenham controle total. Python é uma solução que
contém código-fonte aberto e pode ser estendida para vários fins.
Outra característica marcante em Python é sua aprendizagem marcante nos alunos que
estão iniciando, ela é uma linguagem mais simples tendo assim uma possibilidade de
entendimento e ensinamento melhores para quem está em busca de iniciar na programação, e
aos poucos ele vai aprendendo e aperfeiçoando sua técnica em Python para obter saídas mais
complexas em termos de processamento de dados.
Não adianta que uma linguagem seja fácil de aprender se não for procurado no mercado
de trabalho. Algumas linguagens projetadas especificamente para fins de ensino, como Pascal
e Basic, nunca foram totalmente aceitos no mercado e tiveram que se adaptar por algum tempo
para contornar idiomas que são difíceis de aprender, mas muito mais poderosos, como C + + e
Java, com a introdução de interessantes frameworks e suporte a linguagens em diversos
servidores web, o Python tem se destacado nos últimos anos com tamanha relevância e tem se
destacado no mercado, com Python, pode-se programar essencialmente em qualquer sistema.
Essa linguagem ela também é intuitiva e de fácil manutenção pode ser usado no sistema
operacional Windows ou Linux, contendo também uma vasta biblioteca padrão. Esta biblioteca
fornece recursos para executar as tarefas mais importantes para o desenvolvimento de várias
tarefas. O interpretador Python é escrito nas linguagens C e C ++ para que possa ser portado
para qualquer plataforma que possua compiladores da linguagem, levando em consideração que
C ++ é a linguagem mais utilizada e a base para a prática de todas as informações tecnologia
de formulários. Usada em várias aplicações: Web, desktop, sistemas embarcados, sistemas 3D.

5
3 - O que é uma IDE e qual utilizar?
Um IDE é um pacote de software que consolida as ferramentas básicas necessárias para
escrever e testar softwares. Basicamente um IDE, ou ambiente de desenvolvimento integrado,
é um software que une ferramentas de desenvolvimento em uma única interface gráfica do
usuário (GUI). A seguir, mostraremos alguns IDEs possíveis de trabalhar com a linguagem
Python.

VISUAL STUDIO

Visual Studio foi lançado em fevereiro de 2002, entretanto sua versão beta foi
criada ano anterior da versão final. Esse IDE é uma das mais populares no
mercado dos programadores, de acordo com pesquisa do Stack Overflow, não
somente na linguagem Python como em outras propriedades que o software
proporciona.
A Microsoft criou esse IDE com o intuito de fornecer recursos para o programador, além
da criação de códigos, que depois serão compilados e executados, na linguagem Python há
alternativa de fazer desenvolvimentos WEB – apesar que anos depois a própria Microsoft criou
um IDE somente para esse serviço –, também é possível criar códigos em C# ou C++. O Visual
Studio pode-se encontrar em três formatos diferentes, a Community, Enterprise e Professional;
sendo suportado em dois Sistemas Operacionais: Windows e macOS.

PYCHARM

Lançado em fevereiro de 2010 pela empresa JetBrains, o PyCharm é um

ótimo IDE para desenvolvedores em Python. Sendo desenvolvido para
multiplataforma, como Linux, macOS, e versões do Windows, conta com
a Community Edition, lançada sob a licença Apashe, que permite com que
seus usuários utilizem o software para qualquer finalidade, sendo possível
a modificação e distribuição do mesmo sem a necessidade de pagamento
de qualquer taxa. Além dessa, existe também a Professional Edition, lançada sob uma licença
proprietária conta com recursos extras.
Atualmente oferece aos usuários uma série de recursos, como seu sistema de
multitecnologias, que torna possível o suporte para JavaScript, TypeScript, SQL, HTML/CSS
entre outras, Frameworks de desenvolvimento WEB, assistência inteligente, recursos para
desenvolvimento remoto entre outros.

6
 VISUAL STUDIO CODE

Lançado em 2015 pela Microsoft, o Visual Studio Code, ou VSCode, como é

comumente conhecido, é uma alternativa viável para programar a linguagem
Python. A sua criação teve como foco principal a edição de código para
aplicações WEB, entretanto, baixando extensões é possível fazer a excursão
em Python. Existe a possiblidade de fazer os códigos do VSCode em três
Sistemas Operacionais distintos são: Windows; Linux; macOS.
Existe a comparação com o Visual Studio, também lançado pela Microsoft, porém o
VSCode tem um formato menor para instalação, é um software novo no mercado de
programadores e não há uma variedade de conteúdos que o Visual Studio fornece para ser usado
de outras formas, como usar a linguagem C#.

IDE ESCOLHIDA

O grupo optou por utilizar o Visual Studio Code, por ser o mais recomendado pelos
usuários e estarmos em uma instituição que utiliza uma IDE bem parecida – Visual Studio - em
seu primeiro e segundo ano, assim criando uma familiaridade com a mesma.

4 - Processo de download e instalação da linguagem e da IDE - Baixando o

Visual Studio Code
Inicialmente, iremos baixar o Visual Studio Code, para isso, basta acessar o endereço
“https://code.visualstudio.com/download”. Nesse site, obteremos os links para baixar o Code:

7
 Deve-se selecionar a opção mais adequada para as configurações de seu computador.
Neste caso, utilizaremos o link do Windows e selecionaremos “User Installer - 64 bit”. Ao
clicar, o arquivo já será baixado em seu computador.

Posteriormente, clica-se no arquivo para poder executá-lo, assim, o instalador do Visual

Studio Code irá ser inicializado. Segue-se as instruções iniciais de instalação, configura-se o
local e os atalhos do Software.

8
 Após isso, o Microsoft Visual Studio Code para o usuário já está instalado e pronto para
ser usado.

Agora, já com a instalação do Code, iremos instalar a extensão para que seja possível a
utilização da linguagem Python. Deste modo, no Code, clica-se em “Extensões” localizando no
canto esquerdo, pesquisa-se por “Python”, e procura-se por essa opção (marcada por uma
estrela). Com isso, clica-se em “Instalar”:

9
 Depois da instalação da extensão ser concluída, abrirá uma nova aba no Code. Ao clicar
em “Create a Python File”, já será possível codificar a partir de um novo arquivo na linguagem
Python.

10
 Apesar de ser possível criar arquivos Python (.py), não será possível executá-lo no
Visual Studio Code. Você receberá a mensagem acima.
Para solucionar esse problema, basta clicar em “Download” que você será encaminhado
para o endereço de site ”https://www.python.org/downloads/“. Lá, é possível instalar a
linguagem Python. Cliquemos em “Download Python” que um arquivo será baixado, após isso,
basta executá-lo que uma guia para instalar a linguagem em seu computador aparecerá.

11
 Posteriormente, clique em “Install Now” que o instalador completará a instalação do
Python. Caso a instalação seja um sucesso, aparecerá a seguinte mensagem:

E assim, já será possível codificar em Python e executá-lo no Visual Studio Code sem
problemas.

12
 Capítulo 2 – Apresentando a programação em Python

1 – Exercícios Resolvidos, entendendo na pratica.

A seguir, veremos 16 exercícios resolvidos na linguagem Python, assim demonstrando
na pratica conceitos que a linguagem pode lhe oferecer.

1.0 – Dando os primeiros passos

Antes de desenvolver qualquer aplicação, é necessário ter ao menos um conhecimento
mínimo para conseguir se localizar dentro da IDE (Ambiente de Desenvolvimento Integrado).
Ao abrir o Visual Studio 2019, o desenvolvedor se depara com esta tela inicial, em
seguida, deverá clicar na opção “Criar um projeto”, que está localizada ao inferior do canto
esquerdo da tela.

Ao seguir o passo anterior, o programador será direcionado à esta tela de busca, onde
na opção em que se encontra “Todos os idiomas” irá pesquisar por “Python”.

13
 Ao filtrar as opções oferecidas para a linguagem Python, deverá selecionar a opção
“Aplicativo do Python”.

Por fim, o desenvolvedor será conduzido para esta tela, onde poderá alterar o nome do
projeto e o local em que ele ficará salvo.

14
 Após ter feito este processo, será direcionado para o ambiente no qual poderá
desenvolver suas aplicações na linguagem Python.

1.1 – A partir da digitação da base e altura de um triângulo o programa

deverá calcular sua área e exibi-la no monitor.
Separando a aplicação em três passos: Entrada de dados, operação aritmética e saída de dados.

Passo 1: Entrada de dados

Neste primeiro passo, serão solicitados ao usuário os valores da base e da altura do

triângulo, que serão armazenados respectivamente nas variáveis denominadas como base e
altura.

Posteriormente, é declarado que a entrada de dados é do tipo int, ou seja, só aceita a

entrada de números inteiros como, por exemplo, 1, 5 -12. Na linguagem Python é possível
utilizar:

Tipo Descrição Exemplo

15
 str String (Texto) ‘Olá mundo’
bool Valor Booleano True ou False
int Número Inteiro 2, 8, -15
long Número Inteiro de Valor Arbitrário 5416541658
float Número Real 5.0, 7.2, -12.63
list Lista [1, 4, 10]

Por último, é utilizado o comando input, que serve para ler o que o usuário digitar no
prompt.

Passo 2: Operação Aritmética

Neste segundo passo, serão utilizados conceitos básicos da matemática para calcular a
área do triangulo. Nesta etapa, é declarada a variável area, que vai armazenar o valor da
operação. A linguagem Python tem os seguintes operadores aritméticos:

Operador Descrição Exemplo

+ Adição 2+3
- Subtração 2-2
* Multiplicação 2*4
/ Divisão 10 / 2
// Divisão Inteira 4 // 3
** Exponenciação 2 ** 100
% Resto da Divisão 10 % 2

Passo 3: Saída de dados

Neste passo, será apresentado ao usuário o resultado da operação. É utilizada a função

print, que apresenta ao usuário os dados de maneira legível. Em seguida é utilizado o método
format(), que serve criar uma string que contém campos entre chaves e são substituídos pelos

16
argumentos do format, neste caso, o argumento foi a variável area, que continha o resultado
da operação.

1.2 – Crie um programa que vai calcular o seno e cosseno de um ângulo

digitado pelo usuário. Vejamos como fica a linha de código logo abaixo:

Nas linguagens C# e Java, a biblioteca math não precisamos importar ela no código
como é visto, logo abaixo, na linguagem Python, ou seja, nelas só precisamos colocar o
comando math. e ele já vai mostrar todos os comandos que possíveis de serem executados pela
biblioteca.

Nas próximas linhas é observado a criação da variável para armazenar o valor que o
usuário vai digitar e os cálculos desse número. Usamos somente dois comandos da biblioteca
de Matemática, seno e cosseno, porém existe o comando, caso queira, para calcular a tangente
que seria math.tan().

17
 Por fim, para exibir as variáveis que armazenaram os resultados das operações, como já
é de costume, usamos print(‘’), depois utilizamos { e } para decidir o local onde será mostrado
o valor e o comando .format(variável) para finalizar a linha de código.

Caso queira ser um programador que utiliza poucas linhas de código, existe uma
alternativa para executar o que foi pedido pelo enunciado. Contudo, a linha de apresentação é
diferente do que estamos acostumados.

Invés de usarmos .format(variável) no print, podemos simplificar usar a letra f ou F

antes das aspas simples, também é possível observar que dentro das chaves já está sendo
efetuado o cálculo do cosseno e seno. Logo após a execução da biblioteca math, utilizamos o
comando para exibir somente duas casas decimais.

1.3 – O programa deverá solicitar a digitação de suas 4 notas

bimestrais, feito isso deverá calcular e exibir a sua média final (média
aritmética entre as 4 notas). Feito isso deverá também mostrar as mensagens:
“Você está aprovado! ”, “Você está reprovado!” Ou “Você está de exame” de
acordo com o seguinte critério: Média final maior ou igual a seis o aluno este
aprovado, menor que três reprovados, entre 3 e 6 de exame.
Separando a aplicação em três passos: Entrada de dados, operação aritmética e verificação da
situação do aluno.

Passo 1: Entrada de dados

18
 Neste primeiro passo, serão solicitados ao usuário os valores das notas dos 4
bimestres, que serão armazenados respectivamente nas variáveis denominadas nota1, nota2
nota3 e nota 4.

Passo 2: Operação Aritmética

Neste segundo passo, serão utilizados conceitos básicos da matemática para calcular a
média aritmética entre as 4 notas. Nesta etapa, é declarada a variável media, que vai
armazenar o valor da operação. Posteriormente através na função print e do método format(),
o resultado é apresentado ao usuário.

Passo 3: Verificação da situação do aluno

19
 Neste passo será verificado, por meio da estrutura if-elif -else, a situação do aluno. O
if é uma estrutura condicional, que permite avaliar determinada expressão e de acordo com o
resultado, executar determinada ação. Caso exista mais de uma condição alternativa que
precise ser verificada, deve-se utilizar o elif, como mostra no exemplo acima. Por último, o
else é utilizado para casos onde nenhuma das condições postas anteriormente são satisfeitas.

As condições para comparação podem utilizar de alguns operadores como:

Operador Descrição Exemplo

> Maior que 3>2
< Menor que 2<5
>= Maior igual que 2 >= 2
<= Menor igual que 2 <= 1
!= Diferente de True != False
== Igual a True == 1

Caso o valor da variável media satisfaça a condição, será exibido ao usuário o

resultado correspondente.

1.4 – O programa deverá nos solicitar a digitação de dois números e

um caractere, sendo que este poderá ser “+”, “-”, “*” ou “/”. Mediante o
caractere digitado fazer o respectivo cálculo e exibir o resultado, se o
caractere não corresponder a nenhum dos 4 caracteres em questão exibir
mensagem de erro. Este programa obrigatoriamente deverá ser feito usando
um ninho de ifs.
Inicialmente, o programa exige a digitação de dois números juntamente com o caractere
desejado, iniciando-se assim a entrada de dados.

20
 Posteriormente, são declaradas as operações aritméticas a fim de realizar os respectivos
cálculos.

A seguir, tem-se um exemplo de uso de If, que por sua vez tem como objetivo verificar
se o operador aritmético corresponde a um dos quatro da questão. Em caso positivo, o resultado
do cálculo será exibido na tela, caso não houver correspondência será impresso uma mensagem
de erro. É notório que foi aplicado o uso de um “elif”, que é basicamente uma condição
de if junto com else.

1.5 – Idem ao exercício anterior, porém agora a solução deverá ser

desenvolvida usando um switch-case.

Neste caso, não será possível desenvolver o exercício da forma pedida, pois a linguagem
de programação Python não tem switch/case. Entretanto, a maneira mais comum de fazer um
código similar é usando if/else, como foi aplicado no exercício 4.

21
 1.6 – O programa deve começar nos solicitando a digitação de um
número, inteiro e positivo, a partir de então o programa deverá exibir na tela
a tabuada deste número. A entrada de dados não deverá ser validada, vamos
acreditar que o usuário sempre digitará um valor devido.

É feita a criação da variável para armazenar o valor que será digitado pelo usuário e tem
a necessidade de ser um número inteiro, logo após foi feito (para exibir melhor) um print que
vai mostrar 20 travessões em seguida.

Para fazer a execução do cálculo vamos utilizar um laço de repetição, em específico for.
Esse comando em outras linguagens tem uma linha mais extensa a ser digitada, entretanto em
Python o programador não precisa de muito tempo escrevendo e outra característica da
linguagem é que ela conta como se fosse um ser humano normal, ou seja, o Python começa a
contar do número 1 em diante.

22
 O papel do c é somente para ser um contador no laço acima e como foi dito no exercício
que pedia um programa que calculava o seno e cosseno, usamos novamente o f antes das aspas
simples. A função range() é a forma mais simples para incrementar no ciclo.

1.7 – O programa deverá exibir na tela os “n” primeiros termos da

série: 2, 5, 10, 17, 26... onde o valor de “n” deverá ser inicialmente digitado.
Em tempo esclareço que tal série tem como termo geral (x2 + 1) onde x = {1,
2, 3, 4, 5 ...}.

Na imagem acima, podemos ver o início do programa, definindo suas variáveis e seus
devidos valores, pode-se ver também que a variável ‘n’ foi definida para receber um valor do
usuário.

Nesta segunda parte, temos basicamente um identificador de números negativos ou

iguais a 0, usando o while, fazendo com que o valor de ‘n’ seja pedido novamente, enquanto
não for digitado corretamente e usando o break para por um fim no loop.

23
 Aqui temos um laço for para que a sequência seja feita de forma correta, com a função
range dentro do for, podemos pegar todos os valores do intervalo exigido no parâmetro entre
parênteses, ou seja, tudo entre 0 e ‘n’. Em termos matemáticos, temos o contador que soma 1
em todo loop, iniciando em 0 indo até ‘n’, impar é igualado a ímpar + 2, ou seja, a cada loop
ele soma 2 em seu valor, sendo sempre um número ímpar (1, 3, 5, 7, 9...), enquanto valor é
somado ao impar toda vez, assim atualizando o número e agregando um novo valor da
sequência, por fim, exibindo a lista exigida.

1.8 – Temos aqui um clássico, o programa deverá listar no vídeo os

termos da série de Fibonacci (1, 1, 2, 3, 5, 8, 13, 21 ...) menores que 1000.

Primeiramente, definição de variáveis simples para o desenvolvimento da lógica, e um

print, apenas para sinalizar o início da sequência na execução.

Por fim temos um laço de repetição while, onde usamos (‘a’ < 1000) para que se repita
enquanto o valor da lista não for maior que 1000, poderia ser (‘a’<= 1000), porém na sequência
vem um número maior, logo, não é necessário. Primeiro usamos o print para exibir ‘a’ (ou seja,

24
1), assim iniciando a sequência, logo depois temos ‘aux’ como um auxiliar para fazer o sistema
o igualamos com ‘a’, depois ‘a’ foi igualado a ‘b’, por fim, como última operação ‘b = aux +
b’, assim redefinindo o valor de ‘a’ e o exibindo na lista, até q o laço se finalize, retornando a
com valores diferentes, fazendo com que a sequência seja possível.

1.9 – Entrar com dois valores via teclado, onde o segundo deverá ser
maior que o primeiro. Caso contrário solicitar novamente a digitação do
segundo valor, o que deve ser repetido até que o usuário atenda a condição
definida.

Primeiramente, foi definida a primeira variável (n1), de tipo inteiro (int), e foi solicitado que o
usuário digitasse o primeiro valor.

Em seguida, foi criado um laço de repetição (while) onde, enquanto condição for verdadeira, a
segunda variável (n2) é definida e é solicitado que o usuário digite o segundo valor.

Na terceira e última etapa foi utilizada uma estrutura de decisão (if) para impor a condição de
parada. Neste caso, o operador not é utilizado na estrutura de decisão para indicar que a
parada só será feita se a condição (n2<n1) for falsa.

Enquanto o valor de n1 for maior que o valor de n2 o laço de repetição é executado, só

parando o looping quando o valor de n2 for maior ou igual ao de n1.

1.10 – Entrar via teclado com o sexo de determinado usuário, aceitar

somente “F” ou “M” como respostas válidas, caso o valor digitado seja
indevido repetir o processo até que se digite um dos dois caracteres válidos.

25
Na primeira etapa a variável (sexo) foi definida e foi solicitado que o usuário digitasse se o
sexo era feminino (F) ou masculino (M).

Na segunda etapa foi criado um laço de repetição (while), que será executado enquanto o sexo
for diferente de F e M. Nessa etapa é utilizado o método upper() com o objetivo de deixar o
texto digitado pelo usuário em caixa alta, para que facilite a validação feita no laço de
repetição.

Enquanto o sexo digitado pelo usuário for diferente de F e de M, o laço é executado,

solicitando que o usuário digite novamente.

1.11 – O programa deverá nos permitir a digitação de um número

inteiro e positivo, essa entrada deverá ser repetida até que o usuário satisfaça
a condição. Feito isso o programa deverá calcular e exibir o fatorial deste
número. Ao fim questionar se desejamos continuar ou não e essa entrada só
deverá aceitar como resposta “S” ou “N” e a pergunta deverá ser repetida
até que o usuário responda corretamente. Se a resposta for “S” então
deveremos voltar ao início do programa e repetir tudo novamente, caso
contrário o programa deverá ser encerrado.
Inicialmente, receberemos numa variável um valor, logo após, realiza-se um controle
através do “while not numero.isdigit():” que irá verificar se o valor é inteiro e positivo (note
que o tipo do valor recebido pela variável não é especificado, se tivesse sido o caso, não seria
possível colocar uma mensagem de erro de números que não fossem inteiros, apenas seria
mostrado erro no programa). Caso o valor não satisfaça a condição, entrará no laço de repetição
até que um número inteiro e positivo seja digitado. A variável resposta posteriormente será
usada para perguntar se o usuário pretende realizar o fatorial de outro número. Por isso recebe
“S”, ou seja, enquanto resposta for “S”, fará o processo de cálculo de fatorial.

26
 A variável “fatorial” iniciará o fatorial do número selecionado; o “i” funcionará como
um contador auxiliando nas multiplicações do fatorial.

Cria-se um “while” do qual o contador, como foi dito, será a variável “i”. Assim, fatorial
receberá o produto anterior multiplicado pelo contador “i”. Então, por exemplo, fatorial (1) * i
(2) será igual a 2; posteriormente, “i” soma 1, e passa a valer 3. Consequentemente, fatorial
receberá fatorial (2) * i (3), passando a valer 6. Esse processo terminará quando “i” for igual
“int(numero). Note que foi usado “int(numero)” ao invés de apenas “número” pois no momento
em que fora atribuído valor a essa variável, não havia sido especificado o seu tipo, como já foi
dito. Assim, obtêm-se o fatorial do número que o usuário escolher. Posteriormente, através do
comando print, mostra-se o resultado (também usando-se de “int(numero) ao invés de apenas
numero).

Como foi dito, a variável “resposta” servirá para saber se o usuário quer ou não fazer o
fatorial de outro número. O laço “while” controla para que o usuário digite apenas “S” ou “N”.
O comando “.upper()” em frente a string faz com que, mesmo que o usuário digite apenas “s”
ou “n”, funcione da mesma forma, ou seja, “resposta” receberá strings em maiúsculo apenas.

27
Caso a resposta do usuário seja “S”, o programa se repetirá, caso seja “N”, finalizará. Para isso,
todo o programa deve estar dentro do “while” como mostra a figura a seguir:

1.12 – O programa deverá nos permitir digitar e armazenar dez

números na memória do computador. Feito isso exibir os valores digitados
em tela na ordem inversa à da digitação.
Para esse exercício, inicialmente cria-se um vetor, no caso será “y”. A variável “j” será
usada apenas para efeito de design.

Cria-se um “for” com range 10, ou seja, o laço se repetirá 10 vezes. Com o comando
“.append” adiciona-se valor ao vetor.

Após colocar os valores no vetor, basta usar um “for” com o comando “reversed” que o
vetor será mostrado na ordem inversa.

28
 1.13 – O programa deverá nos permitir digitar e armazenar dez
números na memória do computador. Feito isso criar um laço capaz de
calcular a somatória desses 10 valores e então exibir a média desses valores.
Iniciamos o programa declarando um vetor (vet), que na linguagem de programação
Python não se comporta igual na linguagem de programação C. Em Python o vetor não existe,
e ele é como se fosse uma lista que armazena os números. Ao declararmos, colocamos também
outra variavel para fazer a somatória no final. Dentro do laço for, pedimos a digitação de 10
números, que será armazenado e mostrado logo em seguida.

Em seguida vamos entrar em um outro laço de repetição, onde todos os números que
estão armazenados serão somados e atribuídos a variavel ‘s’ somatória. Ao longo que todos os
números foram somados, ele irá sair do laço e fará uma média dos números inseridos, para que
em seguida seja mostrado na tela

29
 1.14 – O programa deverá nos permitir digitar e armazenar dez
números na memória do computador. Feito isso criar um laço capaz de
identificar o maior e o menor dos números digitados e exibi-los ao final.
Iniciamos o programa declarando um vetor (vet), que na linguagem de programação
Python não se comporta igual na linguagem de programação C. Em Python o vetor não existe,
e ele é como se fosse uma lista que armazena os números. Ao declararmos, colocamos também
outra variavel para fazer a somatória no final. Dentro do laço for, pedimos a digitação de 10
números, que será armazenado e mostrado logo em seguida.

Para a verificação do maior e menor número, criamos um laço de repetição (for), cujo o
primeiro número a ser inserido pela pessoa, possuirá automaticamente a posição de menor
número e assim que o segundo número for colocado o laço irá verificar se esse número é maior
ou menor que o primeiro já inserido fazendo essa verificação com todos e apresentando na tela.

30
 1.15 – O programa deverá nos permitir digitar e armazenar o nome e
idade de dez pessoas. Feito isso deverá nos solicitar a digitação de um nome
e então proceder a pesquisa e informar a idade do sujeito pesquisado caso ele
se encontre armazenado, caso contrário informar o fato através de
mensagem “Pessoa não localizada”, ao final verificar se nova consulta é
desejada, validar a resposta do usuário no sentido de só aceitar “S” ou “N”.
Obviamente que no caso de nova consulta a digitação dos dez nomes/idades
não deve ser repetido.
A seguir temos o código completo, que será destrinchado para melhor entendimento:

Há uma diferença enorme entre a criação de matrizes em C# e a criação de matrizes em

Python. A matriz em Python deve ser criada com todas as casas que serão utilizadas, não
somente colocando a quantidade de casas que utilizaremos. Podemos ver a seguir a criação de
uma matriz em nosso programa:

Continuando a analisar o código, veremos o laço de alimentação da matriz, que pedirá

para o usuário digitar o Nome e a Idade da pessoa a quantidade de vezes solicitadas no programa
e armazenar esses dados na matriz:

31
 Após isso é criado um While, que servirá como o do...while do C#, para que seja feita
uma nova pesquisa. Em seguida será feita solicitado ao usuário o nome da pessoa que ele deseja
pesquisar:

Posteriormente ao usuário ter digitado o nome, será feito um laço para que seja varrido
todas as casas da matriz. Logo abaixo do laço vemos a condicionante, onde somente será
inserido na variável salvar a idade da pessoa pesquisada:

Logo abaixo, vemos a condicionante para que a idade da pessoa seja apresentada na tela,
caso a variável salvar não esteja vazia, é printado a idade da pessoa, caso ela esteja, será printada
uma mensagem:

A seguir no código, o usuário é perguntado se ele deseja ou não fazer uma nova pesquisa,
caso sua resposta seja afirmativa, a condicionante a baixo será falsa e retornaremos ao início da
pesquisa, caso contrário, o programa se encerra:

32
 1.16 – Determinado cinema tem 20 fileiras (de 1 a 20) com 15 cadeiras
(de 1 a 15) cada uma, portanto estamos falando de uma sala com 300 assentos,
que deve ser reproduzida através de um array de 20 linhas por 15 colunas. O
programa deve começar solicitando do usuário a digitação de seu nome, o
número da fileira e cadeira em que deseja se sentar, se o assento estiver vazio
reservá-lo registrando no array seu nome, caso contrário informar que o
assento está ocupado. Feito isso o programa deverá nos questionar se
desejamos nova reserva, validando nossa resposta e repetindo todo o
processo.
A seguir temos o código completo, que será destrinchado para melhor entendimento:

Como explicado no exercício anterior, a matriz tem que ser feita uma a uma de suas
casas. Neste trecho do código vemos a criação da matriz:

33
 Assim como no código anterior, utilizaremos o while True para fazermos o processo
quantas vezes o usuário precisar:

No código a seguir, é pedido ao usuário que digite o seu nome, fileira e cadeira que
deseja se sentar:

Logo após, podemos observar a condicionante onde deveremos destrincha-la em

algumas partes:

1 – Vemos que utilizamos “Fileira - 1” e “Cadeira – 1”, isto ocorre, pois, as matrizes
começam no número 0 e vão até o número escolhido -1. Por isso que será utilizado o
Cadeira/Fileira – 1;

2 – É utilizado o comando .split, o qual tem a finalidade de dividir a string. A que

utilizamos, solicitamos que a string seja dividida a cada “,”, podemos ver isso dentro dos
parênteses. Ademais, podemos ver dentro dos colchetes o número 0, que se refere a qual parte
da string iremos utilizar, e neste caso utilizaremos a parte 0, a 1º parte;

34
 3 – Ao passarmos por este processo inteiro, se a 1° parte da string for igual a Ocupado,
retornaremos a mensagem que a cadeira está ocupada, caso contrário, retornamos a mensagem
de sucesso na reserva.

A seguir no código, o usuário é perguntado se ele deseja ou não fazer uma nova pesquisa,
caso sua resposta seja afirmativa, a condicionante a baixo será falsa e retornaremos ao início da
pesquisa, caso contrário, o programa se encerra:

35
 Capítulo 3 – Apresentando a interface gráfica

1 – O que é PyQt5 e como ele funciona?

Para entender o que é PyQt, primeiramente é necessário entender o que é o Qt.

O Qt é um framework utilizado para criar interfaces gráficas. A princípio, era utilizado

somente em C++, porém, devido a necessidade de seus usuários de programar em outras
linguagens e da afinidade que esses tinham com a plataforma, foram desenvolvidas algumas
versões da ferramenta voltadas para a programação em linguagens diferentes, como por
exemplo em Python e Java.

O PyQt5, portanto, é a quinta versão da ferramenta Qt voltada para a programação em

Python

Primeiramente para se obter PyQt5 precisamos ter o Python instado no computador e

obter a instalação do PyQt5, em seguida abriremos o pront de comando e quando o console for
aberto chamaremos a plataforma para ser aberta.

Para termos o bom desenvolvimento da plataforma para o designer, temos que instalar
uma ferramenta chamada QtDesigner, essa ferramenta ela permite a criação de interfaces
utilizando somente recursos Drag-and-Drop ou seja, não serão mais necessárias várias linhas
de código para criar uma janela, com essa ferramenta nós podemos simplesmente clicar e
arrastar os widgets para nossa interface, sendo somente necessário aplicar a lógica para
interação e eventos.

Em seguida, reinicie o pront de comandos, digite "designer" e pressione enter, e já

conseguiremos utilizar a plataforma corretamente.

36
2 – Instalando e conhecendo o PyQt5

Para a instalação do PyQt5 é necessário acessar o prompt de comando do Windows

(CMD), executá-lo como administrador e digitar a seguinte linha de comando: “pip install
pyqt5”, onde “pip” é o gerenciador de pacote do Python. Após esse procedimento, a instalação
do PyQt5 será iniciada. Caso o comando não seja executado, verifique se seu sistema
operacional tem o Python instalado, caso não tenha, é preciso ir até o site da linguagem que é:
https://www.python.org/downloads/ e baixar sua última versão. Linux e Mac Os já vem de
fábrica com o Python instalado.

37
 Assim que estiver instalado, ao clicar para entrar no PyQt5 aparecerá uma janela com
as opções para dar início a primeira parte do processo de criação da interface gráfica. Nesse
caso, será usado o “Main Window”, que cria apenas a janela.
Após realizar os procedimentos citados acima a janela será criada e estará pronta para
uso, sendo possível escolher e posicionar os elementos na interface gráfica. Não é preciso
detalhar cada um dos componentes na tela, somente clicar no elemento desejado e arrastá-lo
para o local escolhido.

38
 No lado esquerdo da tela terão vários menus, os quais disponibilizarão os recursos
responsáveis para a montagem da interface gráfica, conforme segue abaixo nos menus “Input
Widget” e “Containers”:

39
 Nos menus “Item Widgets” e “Item Views” encontram-se as ferramentas para organizar
as informações em listas, tabelas, árvores e colunas.

40
 No menu “Buttons” encontram-se vários tipos de botões com diversas funcionalidades.
Enquanto no menu “Spacers” disponibilizam ferramentas que auxiliam no espaçamento tanto
na vertical quanto na horizontal.

41
 No menu “Layouts” existem diversas opções para a personalização do layout da
interface gráfica. Enquanto no menu “Display Widgets” disponibilizam várias formas de
exibição na tela, como barra de progressão, calendário, gráfico e entre outras ferramentas.

42
 Na barra lateral localizada no canto direito da tela, estão as propriedades relativas ao
elemento selecionado, assim, pode-se personalizar o nome, a fonte, definir o tamanho, a cor e
entre outras permissões.

43
 Ao finalizar a construção da interface gráfica, será necessário salvar esse projeto para
posteriormente gerar o mesmo arquivo em Python e continuar editando-o.

44
 Após clicar em salvar, o arquivo será salvo com a extensão “ui”, conforme o exemplo
abaixo:

Em seguida será preciso acessar o terminal do Windows e digitar a linha de comando

“pyuic5 –x teste.ui –o teste.py”, onde “ui” localizado no comando “pyuic5” é a extensão do
arquivo anteriormente salvo; o “-x” seguido do nome do projeto Qt Designer, o qual será gerado
em Python, que nesse caso é “teste.ui”, e por fim, inserir o “-o” seguido do mesmo nome do
projeto ou um novo nome e é necessário estar acompanhado da extensão “py”. Em seguida,
aperte a tecla “Enter”.

45
 Caso não apareça nenhum tipo de divergência ao pular para a linha de baixo o arquivo
foi gerado com sucesso, conforme o exemplo abaixo:

Logo após a criação do arquivo de extensão “.py”, o mesmo será aberto na IDE
escolhida, no caso Visual Studio Code (VSCode), e sua apresentação será da seguinte forma:

46
47
3 – Criando programas em modo gráfico

A seguir, iremos fazer em modo gráfico, três aplicações já explicadas anteriormente.

1° Programa: Aplicação que calcula o seno e o cosseno de um ângulo.

Passo 1: Construindo o formulário

Adicionando Label’s

A princípio, clicando no ícone Label do menu disposto na lateral esquerda, foram

adicionadas 3 label’s. Label, que traduzido para português seria equivalente a palavra rótulo,

48
é usada como principal método para adicionar textos não editáveis, como títulos fixos ou
label’s dinâmicas, que recebem algum método como resposta.

Adicinando Line Edit’s

Em seguida, foi adicionada 1 Line Edit, espaço editável que servirá de entrada de
dados para o usuário.

Adicionando Push Button

49
 Seguindo na construção do formulário, foi adicionado um Push Button, que nada mais
é do que um botão clicável.

Identificando Função

50
 Após a montagem, no campo “Dialog” do menu disposto na lateral direita, foi feita
uma identificação dos componentes adicionados no formulário. Está parte é importante, pois a
programação da aplicação utilizará desta identificação em sua construção, portanto,
certifique-se de identificar todos os componentes utilizados.

Adicionando texto nas Label’s

51
 Clicando no ícone QLabel do menu disposto na lateral direita, foi alterado o
componente text, que corresponde ao texto que fica visível para o usuário.

Adicionando texto no Push Button

Seguindo na alteração do componente text, foi clicado no Ícone QAbstractButton,

onde foi alterado o conteúdo que ficaria visível para o usuário.

Obs: Ao final de todas estas etapas, não se esqueça de salvar seu projeto!

52
 Vale ressaltar que a parte gráfica pode ser feita de diferentes maneiras utilizando de
todos os recursos disponíveis além dos apresentados nesta aplicação.

Passo 2: Construindo a lógica da aplicação

Transformando ui em py

Utilizando de conceitos já explicados anteriormente neste capítulo, foi

feito uma transformação do arquivo para tornar possível trabalhar na programação com a IDE
selecionada.

Importando Biblioteca

Para tornar possível a utilização e realização de algumas tarefas matemáticas, a

linguagem Python possui um conjunto de funções matemáticas integradas, basta apenas
importar, como feito neste passo utilizando o import math.

Criando um Método

Na parte da programação foi criado o método Calcular(), que terá a mesma lógica deste
mesma aplicação apresentada no capítulo anterior utilizando as funções disponibilizadas pela
biblioteca math, havendo apenas mudanças de sintaxe por estar sendo feita no modo gráfico.

53
Aqui surgem nomenclaturas como def, que serve para declarar o método, self, que permite
acessar os atributos do método, setText, que serve para apresentar a resposta ao usuário.

Chamando o Método

Em seguida, é programado quando o método deve ser chamado, ou seja, quando ele vai
funcionar. Neste caso, sempre que o usuário clicar no botão para calcular.

Programa Inteiro

Veja abaixo o visual do programa inteiro, juntando o que foi importado da ui.

54
Programa Rodando

Visual do programa para o usuário.

55
2° Programa: Aplicação que calcula a média e verificação da situação do usuário.

Passo 1: Construindo o formulário

Adicionando Label’s

A princípio, clicando no ícone Label do menu disposto na lateral esquerda, foram

adicionadas 5 label’s.

Adicionando Push Button

Após isto, foi adicionado um Push Button.

56
Adicinando Line Edit’s

Seguindo na construção do formulário, foram adicionados 4 Line Edit’s.

Identificando Função

Em seguida, foi feita uma identificação dos componentes adicionados no formulário.

57
Adicionando texto nas Label’s

Clicando no ícone QLabel do menu disposto na lateral direita, foi alterado o componente
text.

Adicionando texto no Push Button

Seguindo na alteração do componente text, foi clicado no Ícone QAbstractButton, onde

foi alterado o conteúdo que ficaria visível para o usuário.

58
Passo 2: Construindo a lógica da aplicação

Transformando ui em py

Utilizando de conceitos já explicados anteriormente neste capítulo, foi feito uma

transformação do arquivo.

Criando um Método

Na parte da programação foi criado o método CalcularMed(), que terá a mesma lógica
deste mesma aplicação apresentada no capítulo anterior, utilizando a mesma estrutura
condicional if-elif-else , havendo apenas mudanças de sintaxe por estar sendo feita no modo
gráfico.

Chamando o Método

Após a construção do método, é programado quando o mesmo deve ser chamado. Neste
caso, sempre que o usuário clicar no botão para calcular.

Programa Inteiro
Visual do programa inteiro, juntando o que foi importado da ui.

59
60
Programa Rodando
Conteúdo visível para o usuário.

61
3° Programa: Criando uma calculadora

Para começarmos a interface, definimos “labels” básicas, na aba de “Display Widgets”,

apenas para definir onde ficará cada coisa.

Logo depois, adicionamos um botão ou “Push Button”, na aba de “Buttons”, apenas

como uma futura forma de confirmar os dados digitados.

62
 Para inserir os dados, usamos o “Line Edit”, presente na aba de “Input Widgets”, assim
deixando claro onde os dados vão ficar.

Antes de continuar com a formatação, precisa-se nomear cada um desses elementos,

para que fiquem com uma fácil detecção dentro do código, ou seja, para que fique fácil de ver
onde está cada coisa, seja lá para arrumar um problema ou até mesmo só como mérito de
organização.

63
 Com tudo devidamente nomeado, podemos mudar a “string” das label ou simplesmente
o que fica escrito na label, assim, dando um significado real e visual para cada uma. Aqui
deixamos na ordem de Número 1, Número 2, Operador e o Resultado. Pode-se realizar tal tarefa
apenas clicando em cima e vendo seus dados ao lado, assim como na imagem.

Assim como o último passo das Labels, pode-se realizar a mesma tarefa com o botão,
apenas como mérito de organização.

64
 Ao salvar, o seu arquivo ficará salvo como um arquivo “.ui”. Para converte-lo para o
formato que queremos, que no caso é “.py”, precisamos deste comando acima.

Ao abrir o arquivo, você irá se deparar com essas linhas de código, porém a parte que
você irá programar é apenas a parte lógica, ou seja, os cálculos com operadores.

65
 Aqui é a parte dos cálculos, começando com um “if” para detectar qual operador está
sendo usado na situação, cada operador tendo sua variação, soma (+), subtração (-),
multiplicação (*) e divisão (/), por fim, ao realizar o cálculo, exibirá a mensagem da
determinada operação. Pode-se observar que estamos usando os dados inseridos nas caixas de
textos que colocamos na parte visual “txtNum1” e “txtNum2”.

Aqui temos a continuação do programa, mas o que realmente importa é a parte do

cálculo, ou seja, a operação em si.

Essa linha define que, quando pressionado o botão, o cálculo seja feito e todo o resto
seja efetivamente realizado, assim mostrando tudo corretamente no fim.

66
 Capítulo 4 – Exemplos de programas com a interface gráfica

1 – Calcular a área do triângulo

1. A partir da digitação da base e altura de um triângulo, o programa deverá calcular
sua área e exibi-la no monitor.

Primeiramente, o formulário foi construído adicionando Label’s, Line Edit’s e Push

Button’s. Em seguida, foram adicionados textos para cada uma das Label’s e dos Push Button’s,
a fim de facilitar a compreensão por parte do usuário. Também foi feita a identificação de cada
um dos componentes adicionados no formulário, no campo “Dialog”, para que cada
componente pudesse ser identificado durante a programação.
Após a construção do formulário, o arquivo do mesmo foi convertido para “.py”, para
que pudesse ser utilizado na IDE escolhida.

Classe Triângulo

Dando início à parte de programação, foi criada a classe triangulo().

67
 Nesta classe foram criados os métodos: _init_(self), que inicializa as variáveis,
atribuindo a elas o valor “0”; setB(self, _b), que define a variável b como receptora do
parâmetro _b (base); setH(self, _h), que define a variável h como receptora do parâmetro _h
(altura); getB(self), que retorna o valor da variável b; getH(self), retorna o valor da variável h;
e triangulo(self), que, utilizando os valores atribuídos à b e h, calculam a área do triangulo e
retornam o resultado do cálculo.

Classe Erro

Nesta classe, a princípio foi atribuído “false” à variável erro e uma string vazia à variável
mens.

68
 Em seguida, foi desenvolvido o método setErro(_erro), no qual foram declaradas as
variáveis globais erro e mens. Este tem como objetivo verificar se ocorre alguma digitação
indevida durante a inserção dos valores da base e da altura. Caso seja identificado alguma
digitação indevida, a variável erro recebe true e mens recebe _erro.

Os métodos getErro() e getMens() têm como objetivo retornar, respectivamente, as

variáveis erro e mens.

BLL Triangulo

Ao iniciar a BLL a classe Erro foi importada e foi criado o método

validaDados(triangulo), que tem como objetivo identificar se houve algum erro. Em caso de
erro, através de um laço de decisão, é feita a verificação do tipo de erro, que pode ser: base não
preenchida, base com valor não numérico, altura não preenchida e altura com valor não

69
numérico. Após a verificação do erro, é retornada ao usuário uma mensagem comunicando a
existência da falha.

IHM Triangulo

Nesta classe, foi construída a interação entre o formulário e o programa. Primeiramente,

são importadas as classes criadas anteriormente.

70
 A classe Ui_Dialog(object) é onde se encontram especificados cada um dos
componentes adicionados no formulário. Esta classe é gerada automaticamente quando se faz
a conversão do formulário e o insere-se na IDE escolhida.

Após a especificação dos componentes, foi feita a conexão dos métodos de eventos aos
botões.

O método Limpar(self) redefine os campos editáveis (Line Edit’s) para seus valores
iniciais.

71
 O método event_calcular(self) faz com que, ao clicar no botão “calcular”, os valores
inseridos nas Line Edit’s textobase e textoaltura sejam capturados e, após o tratamento de erros,
a área do triangulo seja exibida no campo areadotriangulo.

72
2 – Calcular Salário Horista

O programa inicia-se criando a classe Salario e definindo o valor de cada aspecto.

73
 Então, pode-se definir a mensagem de erro e o que pode causa-la durante o processo.

Assim, importa-se o Erro para a validação dos dados usando if e else para exibir as
mensagens adequadas.

Para a parte principal, todas as classes previamente abertas são importadas para que se
complementem.

74
 Aqui, constrói-se os botões de “calcular” e “limpar” funcionem apropriadamente,
definindo o que cada um faz.

Finaliza-se conectando a lógica dos botões com os botões propriamente ditos.

75
3 – Equação de Segundo Grau
Neste projeto, o PyQt5 Design foi utilizado para o desenvolvimento gráfico da interface
do usuário.
Segue abaixo os componentes necessários para construí-la:

Os “Line Edit” foram inseridos para possibilitar a digitação dos números escolhidos
pelo usuário e exibir o resultado.

76
 As “Labels” foram inseridas com o intuito de identificar cada campo.

Os “Push Button” são os botões que farão as ações necessárias para a progressão do
projeto.

Nas ilustrações abaixo seguem todos os componentes e seus respectivos “objectName”.

Nesta parte, foi feita a inserção dos nomes que aparecerão para o usuário na parte gráfica e dos
“objectName” para facilitar posteriormente na programação.

77
78
 Os “Line Edit” selecionados, como mostrados acima, foram desmarcados como
impossibilitados para a edição, ou seja, enabled = false.

1.1 - CLASSES

79
 Nesse projeto, também foi usada a classe denominada “Erro”, conforme segue abaixo:

Na classe “Equação2G”, foi importada a biblioteca “Math” para auxiliar no cálculo da

equação do segundo grau, na qual a fórmula utilizada foi:

∆ = 𝒃𝟐 − 𝟒 ∗ 𝒂 ∗ 𝒄

80
81
 Para o cálculo das raízes da equação do segundo grau, foram utilizadas as fórmulas
abaixo:

− 𝒂 − √∆
𝒙𝟏 =
𝟐∗𝒂

− 𝒂 + √∆
𝒙𝟐 =
𝟐∗𝒂

82
 Na classe “Equacao2GBLL”, será feita a validação dos dados que foram inseridos,
levando em consideração as devidas regras para o cálculo.
Há casos em que mesmo que os dados forem válidos, o valor de delta (∆) pode resultar
em negativo, nesse caso não haverá valores para x1 e x2, dessa forma exibirá uma mensagem
informando esta particularidade.

Na classe “Equacao2GIHM”, encontram-se os métodos que fornecerão os resultados

esperados e, além disso, irão armazenar toda a codificação gráfica.

83
84
85
 Foram importadas algumas classes e bibliotecas para o funcionamento dos métodos
necessários para quando o usuário estiver navegando pela interface gráfica, conforme segue o
exemplo abaixo:

A primeira importação foi de uma biblioteca do próprio PyQt5 utilizada para exibir uma
mensagem na tela quando o usuário realizar alguma ação. As outras três importações foram de
classes criadas e já citadas acima.

86
 O método acima foi criado para quando o usuário clicar no botão “Calcular”, nele é
possível observar as importações feitas. Assim que o botão “Calcular” for clicado, serão
desabilitados os campos de “Line Edit” para impedir a digitação de novos coeficientes,
posteriormente serão exibidos os resultados na tela, com base nos valores escolhidos pelo
usuário.

87
 O método acima foi criado para quando o usuário clicar no botão “Limpar”.
Basicamente, ao clicar nesse botão, será feita a limpeza de todos os campos, possibilitando que
o usuário faça outra consulta.

Essas duas linhas serão responsáveis por unir os botões aos métodos criados e citados
acima.

1.2 EXECUÇÃO

88
 As ilustrações abaixo demonstram o projeto em execução:

4 – Cadastro livro
- Montando o design

Não se esqueça de salvar e transformar o design em python!

89
- Construindo a lógica

A princípio, foi elaborada uma classe denominada Livro, que por intermédio do método
set será responsável por armazenar os dados inseridos pelo usuário, como o código, o título, o
autor, a editora e o ano do livro. Além disso, por intermédio do método get, a classe apresenta
os respectivos dados “setados” para o usuário.

Posterior a isso, foi criado outro arquivo .py denominado erro.py, que tem como
propósito lidar com os erros do programa, utilizando de mesmos métodos já citados
anteriormente, o método get e o set. Neste trecho, é possível notar o uso de variáveis globais,
que nada mais são do que variáveis acessíveis em todos os escopos do programa. Intercalado
aos métodos, tem-se uma estrutura condicional if/else para determinar se é um erro ou não.

90
 Após isto, foi criado o arquivo Exercício4BLL.py. Nele foi importado o elemento erro
criado anteriormente.

Então, foi feito o trecho do código que irá checar se o usuário preencheu todos os
campos. Nesta parte, foi utilizado o método len() que retorno o número de elementos da lista,
no programa, ele recebe como parâmetro os dados inseridos pelo usuários e posteriormente é
feito a comparação com o número 0, pois se for igual é sinal de que o usuários deixou o campo
em branco.

91
 Ainda na checagem de dados, é analisado se o usuário utilizou algo além de números
para preencher o campo “ano” ou se o número inserido é um valor positivo. Para isto foi
utilizado a estrutura try/except, que serve para tratamento de exceções, logo, se o programa
identificar alguma exceção, algo além de número no campo “ano”, irá retornar ao usuário. Para
checar se o valor é positivo, o ano inserido pelo usuário, por intermédio de um if, será
comparado como valor igual ou menor que 0, caso for, irá retornar ao usuário.

Por fim, foi criado o arquivo denominado Exercicio4IHM.py, onde nele fica
armazenado umas das principais informações sobre o programa. A princípio foram importados
os arquivos necessários.

92
 A classe livro foi adicionada ao def setupUI (def gerada automaticamente com a
conversão do design) para poder ser utilizada como global e ficar acessível em todos os escopos
do programa.

Em seguida, os botões foram configurados e tornados em clicáveis.

O botão “Cadastrar” foi programado para inserir os valores na classe Livro, neste trecho
o arquivo Exercicio4BLL é chamado para fazer a validação dos dados como foi programado
anteriormente. A estrutura condicional if/else foi utilizada para apresentar a mensagem de erro
caso tenha alguma inconsistência nos dados inseridos ou para apresentar a mensagem
informando que os dados foram inseridos com sucesso.

93
 O botão “Consultar” foi programado a partir do código inserido pelo usuário, ele utiliza
de uma falsa base de dados, neste caso o setCodigo, para averiguar se aquele dado havia sido
colocado pelo usuário, além de fazer a checagem dos dados por meio do arquivo
Exercicio4BLL. Caso tenha algum problema, a estrutura condicional retornará uma mensagem
de erro, caso contrário irá retornar com os dados solicitados.

Por fim, o botão “limpar” só limpará os campos utilizados.

94
 Capítulo 5 – Ligando My Sql ao Python
1 – Acesso ao banco de dados

Design do programa:

A partir da digitação do livro, o programa deverá cadastra-lo e, em seguida, emitir uma

mensagem de sucesso no monitor.

Ele também mostrará quando o livro cadastrado for excluído.

95
2 – Construindo a lógica
A base que fora utilizada foi o programa 4 do capítulo anterior, porém as únicas classes
que permaneceram foram: livro e erro.

2.1 – Classe IMH

Na classe IMH, foi construída a interação entre o formulário e o programa.
Primeiramente, foram importadas as classes erro, livro e BLL.

96
 .

Na classe Ui_TelaInicial(object) é onde se encontram especificados cada um dos

componentes adicionados no formulário.

97
 Após a especificação dos componentes, foi feita a conexão dos métodos de eventos aos
botões.

98
 A def Cadastrar foi criada para que, quando o usuário pressionar o botão Cadastrar, os
dados necessários serão enviados para a BLL.

A def Consultar foi criada para que, assim que o usuário pressionar o botão Consultar,
os dados necessários para a BLL serão enviados.

99
 Após a exibição dos dados, são excluídos todos os dados que estão na memória do
programa, evitando qualquer tipo de interferência.

A def Limpar foi criada para que, assim que o usuário pressionar o botão limpar, todas
as informações presentes nos campos serão apagadas.

100
 As defs Excluir e Alterar foram criadas para, assim que o usuário pressionar o botão
excluir ou o alterar, enviar-se-á os dados necessários para a BLL. Os dados serão validados,
verificando se está tudo correto. Se não estiver correto, a mensagem de erro da classe erro será
gerada. E, caso tudo esteja correto, será apresentada a mensagem de que foi inserido com
sucesso.

2.2 – Classe BLL

Para começar, é necessário importar as classes Erro e DAL, em seguida define-se três
defs, uma para chamar a pagina DAL e conectar com o banco de dados, outra para chamar a
pagina DAL e desconectar com o banco de dados e a última para verificar o método
validaCodigo(livro, op), que tem como objetivo identificar se houve algum erro. O último If é
utilizado para fazer a análise de casos: caso seja c, consulta o livro, caso seja outra letra, deleta
o livro.

101
 Em caso de erro, através de um laço de decisão, é feita a verificação do tipo de erro, que
pode ser: código, título, autor, editora não preenchido corretamente, entre outros. Após a
verificação do erro, é retornada ao usuário uma mensagem comunicando a existência da falha.

102
 Aqui, o If é utilizado para fazer uma análise de casos: caso seja i, insere o livro, caso
seja outra letra, atualiza o livro.

2.3 – Classe DAL

Nessa classe, importa-se a biblioteca mysql.connector e a classe Erro, em seguida cria-
se a variável que recebe a instancia do connector e faz a conexão com o banco. O primeiro def
criado tem o objetivo de fazer a conexão entre o programa e o banco, nesse If percebe-se que,
ao conectar o banco, é exibido no prompt uma mensagem informando que foi conectado e em
qual banco foi conectado. O segundo def foi criado para desconectar do banco de dados.

Nessa segunda parte da DAL foram criadas duas defs, a primeira foi criada para inserir
um livro, com o cursor e o comando SQL e a segunda criada para consultar um livro, com o
cursor e o comando SQL. Nota-se na segunda que para que seja possível fazer a consulta do
livro selecionado pelo usuário, utiliza-se o código inserido anteriormente e, para ter certeza de
que o livro consultado está cadastrado no banco, utiliza-se o If.

103
 Na terceira e última parte do DAL, tem-se mais duas defs: a def Excluir que exclui um
livro com o cursor e o comando SQL e a def Atualizar, que atualiza um livro com o cursor e o
comando SQL. Para que se apague/atualize o livro selecionado pelo usuário deve-se utilizar o
código, inserido anteriormente.

104
 Capítulo 6 – Aplicando Firebase Google no Python

1 - CONSTRUINDO A LÓGICA
Foi reaproveitada a aplicação feita no capítulo anterior, portanto as classes Erro e Livro
continuam idênticas neste projeto, já as demais classes foram devidamente modificadas.

1 - CLASSE DAL

Nessa classe foram importadas as classes: Erro e Pyrebase as quais serão importantes
para a validação de todos os componentes do formulário, além de fazer o acesso com a API.

Foi implementado a configuração padrão do Firebase de Google para que ao longo do

desenvolvimento do projeto haja a criação de aplicações de alta qualidade e performance. Foi
criada também a variável dados com o Firebase.

105
 Na def InserirLivro foi usada a classe child que serve para aceder à sub-nós dentro de
uma referência. Nesse caso, será colocado o livro no Firebase o qual ficará dentro da classe
Livros e será colocado na subclasse com seu devido código ID.

Para a construção dessa classe foi criada a def ConsultarLivro, com o intuito de fazer a
consulta de um livro que anteriormente já foram inseridas suas devidas informações. Para
verificar se realmente o livro está cadastrado no Firebase foi criado o try except, dessa forma
ao fazer a procura do livro e não encontrá-lo será exibido a mensagem que o livro não foi
cadastrado.

A def ExcluirLivro foi criada para fazer a exclusão do cadastro de um livro.

A def AtualizarLivro foi criada para fazer a atualização do cadastro de um livro,

possibilitando a alteração dos campos código, título, autor, editora e ano.

106
2 - CLASSE IMH

Nessa classe foi importado mais duas classes: Erro e LivroBLL. Elas serão importantes
para validação de todos os componentes do formulário e fazer o acesso com a API.

Uma def foi criada para que, ao usuário clicar no botão, os dados necessários serem
enviados para a BLL. Apresenta um if para mostrar a mensagem de erro e o else, uma mensagem
de sucesso.

107
 Logo depois, mais uma def para o botão consultar. Assim que o usuário clicar no botão,
os dados equivalentes e necessários serão enviados para a BLL. Apresenta um if para importar
a mensagem de erro e o else sendo responsável por exibir os dados corretamente.

Após a exibição dos dados, serão excluídos todos os dados que estão na memória do
programa, assim evitando alguma interferência.

Uma def para quando o botão limpar for pressionado todos os dados sejam limpos.

108
 Def criada para assim que o usuário pressionar o botão excluir enviar os dados
necessários para a BLL. Novamente usando o if para uma mensagem de erro e else para uma
mensagem de sucesso.

Essa última def foi criada para quando o usuário apertar o botão alterar, as
informações ou dados necessários sejam enviadas para a BLL. Com um if para importar a
mensagem de erro e o else sendo responsável por exibir os dados corretamente.

109
3 - CLASSE BLL

Nessa classe foi importado mais duas classes: Erro e LivroDAL. Elas serão importantes
para validação de todos os componentes do formulário e fazer o acesso com a API.

Foram necessários somente duas def para fazer a construção dessa classe. A primeira
def é responsável por validar todo o código e possui duas estruturas condicionais, a primeira
condição é para avisar ao usuário da aplicação sobre algum erro e a segunda condição é utilizada
para fazer a análise de casos: caso seja c, consulta o livro, caso seja outra letra, deleta o livro.

Em caso de erro, através de um laço de decisão, é feita a verificação do tipo de erro, que
pode ser: código, título, autor, editora não preenchidos corretamente, entre outros. Após a
verificação do erro, é retornada ao usuário uma mensagem comunicando a existência da falha.

110
 Outra estrutura condicional foi feita para caso a opção seja verdadeira, portanto, o
usuário que vai decidir se quer inserir um novo livro ou se irá atualizar alguma informação já
existente.

111
 Fazendo uma comparação com o capítulo anterior onde foi feita a conexão com o banco
de dados, neste projeto foi feito a conexão com uma API, não sendo necessário usar as defs
conectando e desconectando.

112
 Referências

Monteiro, Leandro Pinho. "Python: características, noções e guia de estudo"; universidade da

tecnologia. Disponível em <https://universidadedatecnologia.com.br/estudo-linguagem-
python-2018/> Acesso em 05 de maio de 2021.
Brito, Edivaldo. "Conheça as características da linguagem Python"; blog do Edivaldo.
Disponível em <https://www.edivaldobrito.com.br/conheca-as-caracteristicas-da-linguagem-
python/> Acesso em 05 de maio de 2021.
Brito, Edivaldo. “Características do Python"; eXcript. Disponível em
<http://excript.com/python/caracteristica-python.html> Acesso em 05 de maio de 2021.
SILVA, I. R. S; SILVA, R. O. Linguagem de Programação Python. Revista Tecnologias em
Projeção, v. 10, n. 1, p. 56-57. 2019.

113