Neste vídeo, vamos construir uma calculadora simples em Python do zero, passo a passo, usando Tkinter para criar a interface gráfica.
Este projeto foi pensado especialmente para quem está começando a programar em Python e quer sair da teoria e começar a criar projetos reais.
Durante o vídeo, você vai aprender como:
✅ Criar uma janela gráfica com Tkinter
✅ Configurar tamanho, título e aparência da janela
✅ Dividir a interface usando Frames
✅ Criar e posicionar botões
✅ Trabalhar com cores, fontes e estilos
✅ Criar um display para mostrar os valores
✅ Capturar os valores digitados pelo usuário
✅ Trabalhar com funções em Python
✅ Usar lambda em comandos de botões
✅ Utilizar variáveis globais
✅ Realizar operações matemáticas
✅ Usar eval() para avaliar expressões
✅ Criar a função para limpar a calculadora
✅ Exibir o resultado diretamente na interface
No final, teremos uma calculadora funcional feita em Python, construída passo a passo desde a primeira linha de código.
Se você está aprendendo Python e quer começar a criar seus próprios projetos, este é um ótimo exercício para praticar seus conhecimentos.
Não se limite a assistir: escreva o código junto comigo e tente melhorar o projeto depois!
Tecnologias utilizadas:
Python
Tkinter
ttk
Gostou do vídeo? Deixe o seu like, inscreva-se no canal e compartilhe com alguém que também está aprendendo Python.
#Python #PythonParaIniciantes #Tkinter #Programação #ProjetosPython
Show More Show Less View Video Transcript
0:00
Iremos aprender como criar uma
0:01
calculadora simples em Python, que essa
0:04
aqui será a nossa calculadora. Então,
0:06
iremos dar em início à nossa calculadora
0:09
que está aqui. Essa calculadora aqui nós
0:11
iremos criá-la em diversas etapas.
0:13
Teremos a primeira etapa, a segunda
0:14
etapa, a terceira etapa,
0:17
a quarta etapa, a quinta etapa e a
0:19
sexta, sétima, a sexta etapa. E por fim,
0:23
teremos resultado como este aqui. Então,
0:25
começaremos aqui na primeira etapa. na
0:27
primeira etapa onde nós temos que é
0:29
criar um novo ficheiro em Python e
0:31
depois importamos as bibliotecas
0:33
necessárias para dentro desse novo
0:34
script em Python. Então vamos criar aqui
0:36
fazer primeiro a nossa etapa que é criar
0:38
a nossa calculadora em Python. Então
0:40
para isso aqui temos aqui teremos que
0:42
primeiramente criar um novo script em
0:43
Python, depois importar essas a
0:46
biblioteca ticker para dentro do nosso
0:47
script. Então isto vai ser
0:52
então vai no teu texto editor, cria um
0:55
novo ficheiro em Python. Então irei
0:56
criar aqui minha irei chamá-lo de main.
0:59
Main em inglês que significa principal
1:02
ou início ou algo assim do gênero. Então
1:04
irei chamar-me main.p.
1:07
Então depois disso aqui terei que
1:09
importar como diz aqui na nossa primeira
1:10
etapa, como diz aqui na nossa etapa,
1:12
cria e importa as bibliotecas
1:14
necessárias para dentro do script que é.
1:15
Então aqui como nós iremos usar o tick,
1:18
então teremos que importar o tick para
1:19
dentro desse script que nós acabamos de
1:21
criar aqui. From ticker importa todos e
1:23
from tick importa ttk. Aqui nessa
1:26
primeira linha onde diz from interport
1:29
aqui o asterix. O asterix em Python
1:31
significa
1:33
importar tudo que estiver nesta
1:34
biblioteca aqui. Então tudo que estiver
1:37
numa determinada biblioteca. Então
1:39
quando você vê sempre em Python alguém
1:42
escrever tipo from qualquer biblioteca
1:44
importa asterix. Então quer dizer que a
1:47
partir daquela biblioteca importa tudo
1:49
que estiver dentro daquela biblioteca. E
1:50
aqui embaixo temos a segunda linha de
1:52
novo onde temos frontic interport ttk.
1:56
TTIQ é uma parte do Tinter que nos
1:58
oferece outros widgets mais avançados em
2:01
Tinter. Então iremos fazer isso aqui que
2:04
vai nos dar. Voltando aqui isso vai ser
2:06
então
2:08
e recomendar aqui importando ti
2:12
importando tiquinos.
2:15
Deixa só me aumentar um pouquinho mais o
2:16
zoom para poderem ver melhor o que é.
2:19
Temos aqui importante vamos fazer
2:21
primeiro aqui prontinter.
2:26
Desculpa import,
2:32
como nós dizemos aqui, o al que
2:34
significa f importa todos aqui ox e
2:37
depois vamos tirar mes
2:43
import.
2:45
Ok.
2:50
Então, depois disso aqui, iremos aquiir
2:52
para a nossa segunda etapa, que é a
2:54
etapa dois, que que será cri a janela e
2:57
faz configurações básicas da janela.
2:59
Então aqui quer dizer que nós iremos
3:00
criar uma nova janela em TIC interessa
3:03
janela aqui iremos criar algumas
3:04
definições básicas como o nome da janela
3:07
e também o iremos definir mais outras
3:11
coisas que t a ver com essa janela.
3:13
Então isto aqui vai ser o seguinte, OK?
3:17
Então isto vai ser o seguinte, devemos
3:19
criar uma nova janela, como diz na nossa
3:21
primeira, na nossa segunda etapa. Então
3:23
para criarmos janela, então vai ser
3:24
janela e a chamar de janela será igual a
3:28
Q
3:29
fechar.
3:31
Então este tick aqui que metemos aqui,
3:34
isso aqui vem vem a partir daqui do
3:36
fromt inter importa tudo que é este o
3:38
asterx aqui. Então depois disso irei
3:41
definir um título da janela. janela
3:43
ponto title que é em inglês. Está abrir
3:47
title abrir parent e aqui dentro do do
3:50
title iremos meter o nome para nome
3:52
dessa janela aqui. Então irei chamá-la
3:54
de calculadora calculadora
3:57
desse jeito.
4:00
Salvar. Então eh depois disso também
4:03
irei chamar o main loop que irá nos
4:05
permitir executarmos a nossa janela.
4:07
tentar instalar essa janela
4:10
ponto main ponto main loop aqui abrir e
4:13
fechar então depois disso aqui i
4:15
simplesmente executar para vermos o que
4:17
nós temos
4:19
que aper muito bem como resultado tá
4:20
aqui obos essa janela aqui é pequena,
4:23
podemos expandi-la toda e fazer aqui
4:25
então tá aqui aqui tá escrito calculador
4:28
nós demos o título aqui calculador aqui
4:30
esta parte aqui calculadora então agora
4:32
vamos definir alguns aspectos que tem a
4:35
ver com a largura e comprimento dessa
4:36
janela
4:37
como nos diz na nossa na segunda etapa.
4:39
Então este vai ser para definirmos a
4:41
largura e o comprimento da janela. Então
4:44
vamos usar o config
4:47
do tick. Então isso vai ser janela ponto
4:50
config desse jeito aqui ó.
4:53
Ou melhor dizer para em vez de usarmos o
4:55
config iremos usar o geometry que é
4:57
muito mais simples. Então isso vai ser
4:58
janela geometry.
5:01
abrir e fechar e dentro teremos passar
5:03
os valores para a largura e o
5:04
comprimento. OK? Pois muito bem. Então
5:07
aqui dentro do geometry, aqui dentro do
5:09
geometry o primeiro valor que nós
5:11
vamosos passar é o valor para a largura
5:13
e o segundo valor será o valor para o
5:15
comprimento. Então isto aqui deve deve
5:19
ficar dentro de parênteses ó, descul
5:21
dentro das vírgulas altas. Então vai ser
5:24
então para a largura e direi dá um valor
5:26
de 235
5:27
e depois para separá-los entre o valor
5:30
de largura e comprimento usa
5:31
simplesmente o x. Então para a largura
5:34
terei um valor de 235 e para o
5:36
comprimento irei dar um valor de 318. Ó,
5:40
pois esses valores aqui são valores que
5:41
eu tentei, então vi que o este tamanho
5:44
aqui será bom para esse aplic para esse
5:46
aplicativo. Então você vai passando aqui
5:48
valores que você achar melhor para o seu
5:49
aplicativo. Depois disso, irei salvar e
5:52
executar para ver que eu tenho como
5:54
resultado. Depois disso, tá aqui, obtive
5:57
um resultado como este aqui, que é um
5:59
tamanho de uma calculadora. Como por
6:00
exemplo aqui tem 200 de largura e 318 de
6:05
comprimento.
6:06
Temos aqui a nossa calculadora, temos
6:08
aqui o nome por cima que é calculadora e
6:10
temos aqui definimos a nossa janela a
6:12
largura e o comprimento. Agora iremos
6:15
definir algum
6:17
algumas cores para que nós iremos usar
6:19
neste aplicativo aqui. Então primeiro
6:22
vamos lá ver nas nossas etapas o que nós
6:24
devemos fazer a seguir.
6:27
OK. Voltando aqui, temos a nossa
6:29
primeira etapa que importamos o tiger,
6:30
segunda etapa, já criamos a janela e
6:32
fizemos algumas configurações. E agora
6:34
aqui na terceira etapa, onde está aqui,
6:36
divide a janela em dois quadros e faça
6:39
algumas configurações nelas.
6:42
Então, como é calculadora, todos nós
6:44
sabemos muito bem que a calculadora está
6:46
dividida em duas partes. A primeira
6:47
parte aqui, que é a parte do onde temos
6:50
o visor, posso assim dizer, o display,
6:52
melhor dizer, onde apresenta os números.
6:54
E a segunda parte é a parte onde
6:56
apresenta os botões. Então também iremos
6:59
fazer o mesmo para aqui para este essa
7:02
janela que acabamos de criar. Iremos
7:04
dividi-la em duas partes. A primeira
7:06
parte será o display e a segunda parte
7:08
será o E a segunda parte será a parte
7:11
onde nós iremos pôr os botões. Então,
7:13
pois em Tick Inter Python para dividir
7:17
uma janela em partes diferentes, frame
7:21
será sempre é uma boa opção, ou melhor
7:23
dizer possa-se dizer a melhor opção para
7:25
se obter esse resultado. Então aqui
7:27
iremos usar o frame frames para podermos
7:29
dividir. Iremos tirar dois frames. O
7:31
primeiro frame será aqui para o display
7:32
e o segundo frame será aqui para essa
7:34
parte aqui de botões. Então para
7:36
fazermos isso, isto vai ser
7:40
vou dar aqui um espaço.
7:42
Então tirei, então irei dar para o
7:45
primeiro para o display então chamar de
7:47
frame
7:49
fazer isso. Então ira chamar de frame
7:51
tela como é ir apresentá-lo. Então isso
7:54
vai ser vai ser a frame, abrir e fechar,
7:58
onde vou passar a instância janela aqui,
8:00
porque é essa janela aqui que nós iremos
8:02
criar esse frame. Então vai ser janela
8:07
e depois vou dar o comprimento para este
8:10
frame. Então isto vai ser wid para wid
8:13
para
8:15
ah, desculpe, para a largura vai ser
8:18
irei dar uns 300, não acho que o 300 é
8:20
muitos. irei dar uns irei user esse
8:22
comprimento aqui mesmo aqui 235, então
8:24
isso vai ser 235
8:27
de 235 de largura e para o outro para
8:32
comp a altura, então isso vai ser H, que
8:36
é isso aí e i dar uma altura de deixa-me
8:39
ver, acho que os 50 vai ser suficiente
8:41
suficiente ou melhor eh não melhor vou
8:44
pôr o 50, depois iremos testar para ver
8:47
quanto é que nós obtemos. E aqui irei
8:49
usar E aqui irei usar o sistema de grid
8:51
para fazer isto. Como apenas são dois
8:53
quadros, usando grid será uma melhor
8:55
opção. Então isso vai ser frame abrir
8:57
tela
8:59
ponto
9:01
grid desse jeito aqui desculpa ponto
9:04
grid.
9:06
Abrir para o nosso row. Então vou ter
9:09
aqui row,
9:11
vou lhe meter no row, no na na primeira
9:14
linha que é o row zero. E para a coluna
9:17
também irei pô-lo na coluna zero. Depois
9:20
disso irei salvar e executar para ver o
9:23
que eu tenho.
9:27
OK. Obtivemos esse resultado aqui. Aqui
9:29
o frame está aqui. Então, como podemos
9:31
ver aqui, não estamos a conseguir ver o
9:33
nosso resultado. Então, para isso,
9:35
iremos definir algumas cores que nós
9:36
iremos usar para esse programa aqui. Eu
9:39
uso muito o Google Color Pck e que este
9:41
aqui, deixa-me mostrar. Então, vir aqui
9:44
na Google, irei pesquisar por color
9:48
desse jeito aqui. Color picker, que é
9:50
isto aqui é color picker. Enter.
9:55
Ya, aqui
9:57
eu uso muito isso aqui para definir
9:59
algumas cores que eu irei usar para um
10:02
determinado programa. Então aqui, por
10:04
exemplo, e deixa-me escolher uma cor
10:05
preta para poder diferenciar a janela.
10:08
OK? Então tem aqui conseguir uma cor
10:10
preta, irei copiar aqui o valor dele a
10:13
decimal
10:14
aqui no no meu que aqui por cima irei
10:17
definir algumas cores que irei usar para
10:19
o programa. Então irei pôr aqui como um
10:22
comentário cores. Então a cor um irei
10:25
escrever simplesmente cor um e irei p
10:28
igual a
10:30
abrir e fechar desse jeito aqui.
10:34
Essa cor aqui será para preta. Deixa
10:36
comentar. Vou meter preta.
10:40
Então aqui no nosso frame que acabamos
10:41
de criar irei definê-la como
10:45
um background preta. Então para isso
10:47
então virei aqui irei fazer is BG BG que
10:49
significa background irei meter cor
10:55
irei salvar e depois disso irei executar
10:59
de novo para ver o nosso resultado já tá
11:01
aqui como podemos ver aqui o o nosso
11:04
frame está aqui tá feito e
11:09
o background ou melhor dizer a cor do
11:10
fundo foi definida como preta então ok
11:13
então em vez disso aqui irei remover
11:15
aqui essa a cor preta para a o nosso
11:19
frame em V. Irei meter aqui para a
11:21
janela irei defini-la como cor preta.
11:26
Então irei pôr aqui na janela como o
11:29
background preta. Então isso vai ser
11:31
para a janela para fazermos isso.
11:32
Entãoar jeito de janela pon config
11:37
abrir e fechar. E aqui dentro você passa
11:39
a propriedade que você deseja alterar.
11:41
Então aqui como nós desejamos alterar o
11:43
background isso vai ser BG.
11:46
abrir a cor um que temos lá e salvar e
11:52
executar para vermos o nosso resultado.
11:54
Ya, como temos aqui o nosso resultado,
11:58
desculpa,
12:00
temos aqui o nosso resultado. A cor do
12:02
fundo dessa janela aqui foi definida
12:03
como preta e essa aqui de cima é o nosso
12:06
frame. Então, eh, irei
12:10
irei irei pausar o vídeo um pouquinho e
12:13
definir algumas cores, depois irei
12:14
apresentá-los. as cores que nós iremos
12:16
usar. E esse processo irei fazer usando
12:19
aqui, como eu havia dito usando o color
12:21
picker. Então para isso então isto vai
12:23
ser OK pessoal. Não, aqui está definir
12:25
algumas cores que nós iremos usar para
12:27
esse projeto aqui. Tem aqui para a cor
12:29
preta, tem esta cor aqui que será a cor
12:31
um, para a branca, a cor dois, para o
12:34
azul carregado que nós também iremos
12:35
usar para esse aplicativo. Tem aqui cor
12:37
três e para cor cisenta tá aqui cor
12:40
quatro e para a cor laranja que iremos
12:43
usar também vai ser aqui a cor cinco.
12:46
Então o que nós estamos fazer é
12:46
definindo a cor do fundo da nossa janela
12:49
que que seria a cor preta que está aqui.
12:51
cor preta que é a cor 1 pg config e
12:55
acabamos de configurar. Então agora para
12:57
o nosso frame por enquanto iremos
12:59
deixá-lo 60 mesmo. Então iremos executar
13:02
para ver o que nós temos até agora.
13:06
Como temos aqui, esse é o nosso
13:07
resultado que nós temos até agora.
13:09
Calculadora. Então o fundo da nossa
13:11
calcul da nossa janela está definida
13:13
como preta. Esse aqui é o frame que nós
13:15
acabamos de criar aqui h pouquinho.
13:16
Então agora iremos criar o nosso segundo
13:18
frame, como temos aqui no na nossa
13:20
etapa. Deixa mostrar.
13:24
Na nossa etapa temos aqui o nosso
13:26
segundo frame que nós devemos criar. O
13:28
primeiro frame, este aqui já acabamos de
13:30
criar e o segundo frame, este aqui que
13:33
nós também devemos criar, que vai ser
13:35
esse aqui onde nós vamos meter os
13:37
botões. Então para isso isto vai ser,
13:44
venho cá e já temos o primeiro frame que
13:47
é o frame tela. E o segundo frame irei
13:49
chamá-lo de frame quadro ou corpo, tanto
13:53
faz. Então irei simples copiar isso aqui
13:55
e colar aqui em vez de tela irei alterar
13:58
o nome para
14:01
pode ser pode ser quadro ou então irei
14:03
chamá-lo de corpo como também como será
14:05
o corpo nós iremos p os botões então
14:07
isso vai ser corpo
14:12
i p o mesmo em português e aqui o
14:14
tamanho irei deixar a largura
14:16
simplesmente que irei aumentar um
14:18
pouquinho para deixa-me ver se já
14:21
tiramos aqui aqui se vemos se vimos aqui
14:23
Aqui na nossa largura já tiramos 50.
14:27
Então se fazemos 50 men 318 - 50 vai nos
14:33
dar aproximadamente a uns, deixa-me ver
14:37
a minha calculadora.
14:39
Ah, vou fazer lá 318 - 50 vai nos dar
14:43
uns 268. OK? Então aqui para o
14:46
comprimento vamos para uns 268.
14:50
Salvar.
14:52
E aqui em vez de aqui em vez de row 1,
14:55
iremos passar para row em vez de row
14:58
zero, desculpa, iremos passar o row 1.
15:01
Depois vai ser o primeiro row, depois
15:03
vai para o segundo row, que é o aqui,
15:05
como sabemos começa a a numeração começa
15:07
no zero e vai 1 2 3 em diante e a coluna
15:11
iremos manter. Então, depois disso vamos
15:12
executar para ver o que nós temos.
15:14
Deixa-me fechar o anterior.
15:17
Se eu executar,
15:19
ya, temos aqui, como sabemos, o nosso
15:21
fundo aqui é cor preta, mas como aqui o
15:24
nosso corpo está definido
15:27
como corenta, tá aqui. Aqui temos o
15:29
primeiro frame e temos o segundo cor, o
15:31
e o segundo frame. OK? Então, iremos
15:34
prosseguir para a nossa próxima etapa
15:36
para ver o que nós devemos fazer na
15:37
nossa calculadora.
15:42
OK? Voltando aqui na nossa etapa, temos
15:43
aqui a etapa três, que é dividir a
15:45
janela em dois. Acabamos de dividir essa
15:47
janela aqui em duas partes, que a
15:49
primeira parte que é para tela e a
15:51
segunda parte que é para o nosso para o
15:53
corpo. Desculpa, voltando. E agora aqui
15:56
iremos definir algumas cores do fundo
15:58
para a nossa janela, para para a nossa
16:00
tela e também para o nosso corpo. Então
16:03
aqui iremos definir como um azul
16:06
carregado. Como podemos ver aqui, temos
16:08
aqui esse aqui é o nosso final que nós
16:10
queremos obter. Então aqui na tela, no
16:12
display aqui, se vemos bem a cor que
16:15
está aqui é o azul carregado como a cor
16:18
do fundo da tela. E aqui para o corpo
16:20
acho que mante-se mesmo como preta.
16:22
Então vamos definir então simplesmente a
16:24
cor do fundo aqui do nosso display.
16:26
Então isto vai ser
16:31
OK, se eu voltar aqui no display, virei
16:34
aqui,
16:36
irei dar um espaçozinho para definirmos
16:38
a cor do fundo, já sabemos que é o BG,
16:40
que é o background, mas vai ser BG, vai
16:43
ser igual a para, deixa-me ver aqui
16:45
nossas cores, para azul carregado, temos
16:46
aqui cor 3. Então isso vai ser vai ser
16:48
igual a cor 3. Salvar. E depois disso
16:52
vou executar para ver o que nós obtemos.
16:54
Então isto vai ser ya, como vocês podem
16:57
ver aqui, o aplicativo já tem já tá ter
16:59
um aspecto
17:01
melhorado, OK? Posso assim dizer, está
17:03
aqui e para aqui embaixo aqui no nosso
17:05
corpo, vamos deixar simplesmente por
17:06
enquanto deste jeito. Então voltando lá
17:09
nas nossas etapas,
17:14
tá? Camos nossa a etapa um, a etapa
17:16
dois, a etapa três, a etapa três que
17:18
terminou aqui, onde definimos a cor do
17:20
fundo da dos nossos frames que nós
17:21
acabamos de criar quando dividimos a
17:23
janela em duas partes, a primeira parte
17:24
e a segunda parte. E agora avançando um
17:28
pouquinho agora na etapa quatro onde
17:31
temos aqui, deixa-me ver, cria alguns
17:32
botões e os pões no desculpa, criei
17:36
alguns botões e os põe no frame abaixo.
17:39
Usa o gerenciador de management que é
17:40
melhor achares aqui. Usaremos o place.
17:44
Ok. Então aqui na etapa quatro iremos
17:45
criar alguns botões que nós iremos meter
17:48
aqui para a para este frame aqui, para o
17:51
frame de baixo aqui, que é o frame de
17:52
corpo, porque aqui no nosso display já
17:55
está praticamente pronto, iremos
17:56
simplesmente esperar. Agora vamos
17:58
atender aqui primeiro o nosso corpo que
18:01
onde iremos criar alguns botões aqui que
18:04
vai se pôr lá dentro do frame. Então
18:06
isto aqui vai ser, deixa-me ver,
18:09
voltando aqui no nosso aplicativo, no
18:11
nosso main, então já criamos frames.
18:14
Deixa-me ver, vou comentar aqui.
18:18
Criando frames.
18:22
E agora aqui vamos criar alguns botões.
18:24
vai ser criando
18:28
botões
18:30
e resolvar. Então,
18:33
tá iremos alguns botões que nós iremos p
18:35
dentro do nosso para do nosso frame
18:37
corpo. Então isto aqui vai ser
18:40
para botões de R chamado de B. Como vai
18:42
ser vários botões chamado de B1, irei
18:44
começar com B1 que vai ser igual aos
18:47
chamar classe botão, que é o botão de
18:50
button.
18:51
Esse aqui depois disso irei abrir. Então
18:54
esse botão aqui que nós criamos iremos
18:56
pô-lo para dentro do frame corpo. Então
18:58
iremos passar para com a primeira
18:59
instância que é o frame corpo. Depois
19:01
disto iremos abrir e fez abrir. Ó,
19:04
desculpa, depois disto iremos daremos um
19:05
espaço. E agora vamos criar o texto que
19:08
irá apresentar nesse botão. Então aqui
19:10
vai ser como texto vai ser igual a
19:15
Então esse aqui o primeiro botão que nós
19:16
iremos criar. Deixa me ver aqui no nosso
19:20
no nosso guia. Então, o primeiro botão
19:21
deve ser aqui o botão que tem aqui o C,
19:23
que é o clean, que é limpar para limpar.
19:26
Então, esse botão aqui vai ser que
19:27
devemos criar primeiro. Então, volto
19:29
aqui. Então, aqui, como já sabemos, o
19:32
primeiro deve ser o clean. Deixa-me
19:35
aumentar um pouquinho o zoom.
19:38
Ah, control B tá muito grande. Ya, como
19:41
é o clean aqui, o texto vai ser C, um C
19:46
maiúsculo, não? esqueçam. E depois disso
19:48
dar espaço e para a largura então vai
19:51
ter wi
20:00
que para a largura. Então isso ira dar
20:02
uma largura de 11. Abrir e para o
20:08
e para o comprimento vai irei dar,
20:10
deixa-me ver uns dois.
20:13
Depois disso, deixa-me testar
20:15
para podermos ver o que nós temos.
20:17
Então,
20:19
primeiramente irei pô-lo, irei fazer
20:22
para que ele possa apresentar na nossa
20:23
tela. Aqui nós iremos usar o place, que
20:26
acho que é mais simples de trabalhar com
20:28
ele em relação ao grid. grid de vez em
20:30
quando complica muito. Então irei usar o
20:33
place simplesmente. Então para X irei l
20:37
pô eh na localização zero e para o Y
20:40
irei pô-lo na localização
20:43
zero. E como nós sabemos aqui o X é a
20:45
parte horizontal e aqui o Y é a parte
20:50
vertical na tela.
20:53
Deixa-me me executar para para podermos
20:55
para que eu possa explicar melhor.
20:59
OK. Então tem aqui, acabei de criar esse
21:01
botão aqui que é este aqui que está aqui
21:03
o C. Então aqui o X, como eu havia dito,
21:06
o X é para o X vai dessa parte, ele
21:09
começa aqui do zero e vai andando até em
21:11
diante. Já o o Y, que é o vertical, ele
21:14
começa aqui de cima e vai desculp começa
21:17
aqui de cima e vai descaindo até aqui em
21:19
diante. Começa do 0 1 2 3 até em diante,
21:22
até onde até onde d melhor dizer. Ya.
21:25
Então aqui temos o nosso primeiro botão
21:26
que já acabamos de criar que é para que
21:29
serve para limpar. E depois disso vamos
21:31
criar um outros botões que vai ser,
21:34
deixa-me mostrar que vai ser aqui esse
21:36
botão aqui que é para o módulo, que é um
21:40
tipo
21:42
que é um outro tipo de operação que que
21:45
nos dá o resultado que nos dá o
21:47
resultado de resto de uma divisão e
21:49
depois daqui o terceiro vai ser divisão.
21:51
Então vamos criar agora esse botão aqui
21:54
e esse aqui. Então isto vai ser
21:58
então já temos o primeiro botão. Irei
21:59
simplesmente vir aqui, copiar senhora
22:01
aqui faço isso. Colo
22:06
aqui esse era o botão um. Aqui vai ser o
22:08
botão dois.
22:11
Ok? Irei por dois. Se aqui está no X0
22:16
y1, então terei que avançar um pouquinho
22:18
mais esse botão, o botão dois. Em vez
22:20
daqui de
22:22
de zero, então vou tentar uns 118.
22:26
E o Y aqui mantém mesmo, fica mesmo no
22:29
zero. E aqui o segundo botão também tem
22:31
que ter que l avançar mais um pouquinho.
22:33
Deixa-me tentar sentir. 77.
22:37
Acho que vai ser uma boa distância.
22:39
Desculpa. E aqui o texto não vai ser
22:41
esse. Se nós controlarmos aqui, o texto
22:43
vai ser eh o texto vai ser esse aqui que
22:47
é o módulo e aqui é a divisão. Então
22:50
volto lá.
22:51
Deixa-me fechar primeiro aqui. Eh, se eu
22:54
voltar aqui, aqui vai ser o módulo que
22:57
este senhor e aqui vai ser a divisão,
23:01
que é esta aqui. Salvar e reexecutar
23:04
para ver o que nós temos até agora.
23:07
Pois, muito bem, temos aqui e os nossos
23:09
botões já que vamos definir. E ya,
23:12
podemos ver aqui que esse botão aqui tá
23:14
muito distante aqui do fim deste do
23:17
primeiro botão, tá? Teremos que regar
23:19
esse botão aqui um pouquinho mais para
23:20
aqui. Então isto vai ser daqui terminou
23:24
0 180. Vamos lá tentar com 100
23:28
salvar e executar.
23:32
Hum, acho que terei que regular mais um
23:34
pouquinho. Deixa-me ver.
23:40
V de 100 fica 90.
23:47
Ya. OK. Acho que deu um pouquinho. E
23:50
agora aqui, se formos a verificar aqui
23:51
nas nossas etapas, temos aqui esse botão
23:54
aqui, o botão C simplesmente aqui é um
23:56
pouquinho mais grande e aqui o divisão e
23:58
o módulo devem ser um pouquinho mais
24:00
pequeno. Então isto vai nos dar,
24:03
deixa-me ver aqui, terei que reduzir o a
24:06
largura desses dois botões aqui. Então
24:08
esse aqui, o primeiro
24:12
e o segundo aqui deve tenho que reduzir
24:14
um pouquinho. Em vez de 11, vou pôr
24:16
cinco. Salvar. E aqui esse é botão um,
24:20
esse é o botão dois. Aqui fica botão
24:22
três.
24:25
Esse saí fica aqui. Salvei. Muito bem.
24:28
Então venho aqui, fecho e vou executar.
24:35
Já tá aqui. O nosso botão está agora um
24:37
pouquinho mais pequeno e bonito.
24:41
OK.
24:44
OK. Agora, depois disso aqui, então,
24:46
irei configurar os botões aqui para ver
24:48
que cor que nós iremos pô-lo. Deixa-me
24:50
mostrar aqui nas nossas etapas.
24:53
OK, como sabemos aqui, temos aqui os
24:55
nossos botões que nós devemos criar.
24:57
Então, em vez de nós criarmos todos
24:59
esses botões, simplesmente, então,
25:00
criamos aqui a primeira a primeira fila.
25:03
Como podemos, se nós notamos bem que
25:04
esse botão, esses botões aqui, o segundo
25:06
e o terceiro, são praticamente parecidos
25:09
com esses aqui. Então, então
25:10
primeiramente vamos criar o botão aqui
25:12
da primeira fila e depois simplesmente
25:13
vamos copiar e colar e depois fazer
25:15
simplesmente as alterações. Então, assim
25:17
que já criamos essa parte aqui, agora
25:19
vamos definir as cores que vá aparecer
25:21
nesse botão. Então, como podemos ver
25:22
aqui, tem aqui para o esse botão aqui
25:25
grande deve ser cisento e a letra deve
25:28
ser preta. Como estamos aqui a etapa
25:30
cinco, verifica e refaz as configurações
25:32
essenciais como definir cor dos botões,
25:35
que é o que já vamos fazer aqui. Vamos
25:37
definir o botão como corisenta e aqui a
25:41
letra deve ser preta. E aqui é os o
25:44
botão mais à direita. A cor a cor do
25:47
fundo deve ser laranja e a cor da letra
25:50
deve ser branca. Então isto vai ser se
25:53
eu voltar aqui. Então aqui a cor do
25:56
fundo deve ser 60. Então vai ser PG que
26:01
do fundo. Se viemos aqui nas nossas
26:02
cores,
26:04
hum, deixa-me fechar esses essa
26:07
execução. Se vios aqui nas nossas cores,
26:09
temos aqui o a corenta
26:12
é cor, então aqui vai ser BG, vai ser
26:15
cor.
26:21
E esse aqui,
26:23
o BG vai ser
26:27
também corvar.
26:32
E por fim, que é o botão mais à direita,
26:35
a cor deve ser laranja. Então para
26:37
laranja não deixa controlar é a cor
26:39
cinco. Então vai ser cor cinco. Copiar e
26:43
salvar. Então, após disso, vamos
26:45
executar para ver o nosso resultado.
26:49
OK. Muito bem. Tá aqui, tá bonito. Tá
26:51
aqui o nosso resultado. Esse aqui é
26:53
laranja. Laranja. E temos aqui. Então,
26:56
agora as cores,
26:59
as cores das letras devem ser preta.
27:01
Essa aqui mantém mesmo. E aqui deve ser
27:04
branca. Então isto vai ser
27:07
OK para cor branca, tá? Lá em cima.
27:10
Então para a cor da letra, então isso
27:11
vai ser FG, que é esse aqui, for ground.
27:15
Para a cor branca temos aqui, qual é que
27:18
definimos? Definimos cor dois, que é
27:20
para branca, então vai ser cor do OK?
27:26
Irei para isso e executar de novo. Já tá
27:29
aqui, já tá um pouquinho branca. E
27:31
agora, após disso aqui, então vamos
27:33
fazer algumas configurações nesses
27:35
botões para deixarmos um pouquinho mais
27:37
bonito.
27:39
Vamos definir o tipo de fonte desses eh
27:42
do dos nossos botões da para a fonte vai
27:45
ser
27:47
para a fonte vai ser e ira irei usar a
27:50
fonte EV
27:52
e tamanho 13 e um pouquinho de bold para
27:55
deixar negritado.
27:57
OK. Muito bem.
28:00
Desculpa.
28:03
E também i o estilo deste botão, estilo
28:08
que é o relief. Irei usar o estilo Razer
28:11
para puxar o botão um pouquinho mais
28:12
para a frente. Então aí vai ser Razer.
28:16
Aqui o Razer, se vocês escrevessem
28:19
sem as vírgulas altas, devem ser em
28:21
letras maiúsculas. E se você escrever
28:24
dentro das vírgulas altas, as letras
28:25
devem ser minúsculas. Ok? Então, muito
28:28
bem.
28:28
salvar.
28:30
E depois disso também irei meter mais um
28:32
outro estilo que é o over relief.
28:34
Overrelief quer dizer que quando você
28:35
passa o mouse por cima do botão, o que
28:38
que ele deve fazer, que tipo de estilo
28:39
que ele apresentar. Então para isso irei
28:41
meter over
28:44
over relief, irei pôr o estilo re
28:48
region,
28:50
que é esse estilo aqui, o region.
28:54
Ok? Então, estamos aqui, definimos a
28:55
fonte, definimos os estilos e o estilo
28:58
quando passamos o botão por cima. Então,
29:00
irrei salvar
29:02
e executar. É, deixa ver que fecha aqui.
29:04
Exit.
29:08
Agora ele vai salvar isso aqui e
29:09
executar. Lá ver,
29:17
ó. OK. Obtive aqui um R por causa aqui
29:19
da fonte EV. Aqui o tamanho deve ser 13.
29:22
Não, o que veio por engano salvar e
29:25
executar de novo.
29:28
Ya, como podemos ver aqui, temos aqui o
29:30
nosso botão C. Mudou um pouquinho, está
29:34
parecer um pouquinho mais agressivo,
29:35
posso assim dizer. Tá um pouco mais
29:37
grande. E se você notar, cada vez que
29:39
nós passamos o rato por cima, o estilo
29:41
do botão muda. Ver, sai do do estilo
29:44
relief para o ridet, que é essa parte
29:47
aqui onde nós decidimos aqui. Over
29:49
relief. Então, quando passamos o rato
29:51
por cima, ele irá apresentar aquele
29:53
efeito. Então, esse esse o mesmo que
29:55
fizemos aqui, iremos simplesmente ver
29:56
aqui, copiar tudo isto aqui e também
30:00
podmos para dentro dos restantes botões.
30:04
Colar
30:07
e colar. Salvar. Agora vamos executar.
30:14
Ya. Muito bem. Temos aqui o nosso
30:15
resultado,
30:17
temos aqui os nossos botões, tudo. Então
30:19
aqui agora devemos avançar mais um
30:21
pouquinho. Esse botão aqui porque está
30:22
muito próximo deste aqui. Ok, então isto
30:25
vai nos dar, deixa-me ver, vamos voltar
30:28
o o que tinha anteriormente que era o
30:30
118. E aqui manter 177. Vamos executar.
30:38
OK. Muito bem. Exatamente. Está
30:42
definida exatamente como gostaria
30:43
esquecer. Tá aqui o nosso, se passar por
30:45
cima muda de estilo, vem aqui. Então
30:49
vamos comparar esse resultado aqui com o
30:51
que temos lá.
30:54
Eh, vamos lá ver que tem aqui o C aqui.
30:57
Tudo OK. Muito bem.
31:01
Ya, está tudo certo aqui. Este aqui por
31:04
cima já obtemos. E agora o que já
31:07
fizemos, como está ver aqui, quase tudo
31:10
igual. Então iremos copiar simplesmente
31:11
essa primeira pata aqui nós criamos e
31:14
colar quantas vezes? Deixa ver. Uma,
31:15
duas, 3, 4 e colar quatro vezes. E
31:17
depois faço as alterações conforme está
31:20
aqui.
31:23
Então isso vai nos dar, voltando aqui,
31:28
todos esses botões aqui, irei
31:30
simplesmente copiar
31:32
ou desculpa, irei copiar por aqui.
31:42
Vou copiar isso aqui,
31:45
dar um espaçozinho e colar. E eu copiei
31:48
simplesmente aqui o botão dois e o
31:51
terceiro, porque se formos a ver aqui,
31:55
aqui por cima, como podemos ver, esse
31:58
botão aqui C, ele é muito é mais largo
32:01
em relação a esses dois aqui. Então foi
32:02
por isso que eu copiei esses dois aqui.
32:04
Como esses dois aqui são parecidos com
32:05
esses aqui, então irei simplesmente
32:07
replicar eles para poder obter este
32:09
resultado aqui. Então aqui temos aqui
32:12
copiei dois botões.
32:14
Então, depois disso, então até acho que
32:15
copiar dois botões será muito. Irei
32:17
copiar simplesmente um e esse aqui irei
32:21
passá-lo para botar um quatro fica
32:24
quatro e aqui no X fica zero.
32:28
E devem ser quatro botões. Então você
32:31
sai,
32:34
Sky, vem aqui, Sky, vem aqui. É, deixa
32:38
ver. 1 2 3 E por fim irei copiaste esse
32:42
botão aqui. Como sabemos que o último
32:44
botão deve ser de um fundo diferente,
32:48
então aqui vai ser ya, você fica aqui e
32:50
muito bem. OK. Então se deixa-me alterar
32:54
aqui os valores aqui, deixa controlar
32:57
aqui o valor que será.
33:03
Então o primeiro vai ser 7 8 9 e o
33:06
asterix.
33:09
Temos aqui o set
33:14
8
33:17
e o asterisco
33:21
salvar e vou executar para ver o que eu
33:23
tenho até agora.
33:26
Ya, tenho aqui, eu tenho o meu
33:27
resultado. Então, como aqui tenho aqui
33:30
nove o asterix também tá a aparecer
33:32
aqui. Então, tudo isto porque nós não
33:34
alteramos o valor do xou, ou menos o
33:37
valor do y que é a que é o valor
33:42
vertical para podermos fazer descir um
33:44
pouquinho. Então, isto aqui vai ser e
33:46
aqui no asterisco, ó, desculpa, aqui no
33:49
x, no valor vertical iremos alterar os
33:51
valores. Então isto vai nos dar, hum,
33:53
deixa-me tentar
33:59
52.
34:02
Como todos vão estar na mesma linha, é
34:04
por isso que eu tô todos 52. Salvar e
34:07
executar. Vamos lá ver o nosso
34:09
resultado.
34:10
OK. Muito bem bonito. Tá aqui o, como
34:13
podem ver, tudo descaiu, mas só que
34:16
estão em posições diferentes. Por
34:18
exemplo, aqui só simplesmente o novo é
34:19
que tá aparecer aqui é o último, porque
34:20
aqui todos estão na mesma posição aqui
34:23
no X, 0 0. E agora vamos começar a
34:25
avançar cada botão para cada botão para
34:27
que eles possam estar nos seus
34:29
respectivos lugares. Então aqui temos o
34:32
primeiro X, mantém o segundo X e terá
34:36
que avançar um pouquinho. Deixa-me ver.
34:38
Acho que uns
34:39
conto. Deixa-me ver. 59
34:42
por aqui. 118 por 2. Acho que 59 vai ser
34:47
aqui. Deixa-me ver. E executar.
34:51
Ok. Muito bem. Ya, oito já está
34:52
posicionado. Agora vamos avançar o 9 52.
34:57
Aqui vai ser agora o 118 de 9. E se eu
35:01
executar,
35:05
OK. Ya, obtive o resultado que eu estava
35:07
à espera. Tenho aqui o 7, oito, o 9 e o
35:10
asterisco. Tenho aqui se tem esse, tem
35:13
esse. Ok. Muito bem. E agora assim.
35:21
E agora feito isso aqui, como já tem, já
35:23
obtive esse resultado aqui, então
35:24
simplemente copiar isso aqui e replicar
35:27
aqui, colar tudo. E como podemos ver
35:29
aqui, vamos fazer o seguinte.
35:33
É, como havia dito, agora vou
35:35
simplesmente copiar isto tudo aqui e
35:39
colá-lo duas vezes. Uma
35:45
e duas.
35:47
Se eu controlar aqui, quantas vezes? OK.
35:50
Tenho aqui um, dois, tenho aqui esse,
35:53
esse aqui um e dois. Colei duas vezes. E
35:56
esse aqui irei copiar essa parte aqui de
35:58
cima como é igual.
36:01
OK. Voltando aqui, então, já copiei um,
36:04
dois e aqui a parte de cima, como o de
36:07
cima é igual com o de baixo, recopiar
36:11
e colar. Agora vou fazer as alterações
36:15
conforme que comando. OK. Aqui tem o 52.
36:22
Aqui é botão quatro. Botão quatro.
36:25
Aqui vai para
36:28
cinco. Então, 5
36:33
6
36:35
7 vai descaindo
36:39
8.
36:42
E é importante que você dá nome dos
36:44
botões com nomes diferente para que na
36:47
hora de chamá-los não possa haver algum
36:49
conflito entre nomes. Então, depois de
36:51
nove vou para 10.
36:56
Aqui fica 11,
37:00
12,
37:06
13
37:08
e por fim 14.
37:10
Salvar.
37:13
OK.
37:16
Ou acho que cometi um erro.
37:18
Terei que renomear de novo como aqui
37:20
para o 3 4 aqui que tem que ser o cinco
37:25
e não lá então vai ser 5
37:30
6
37:33
7
37:36
8
37:38
9
37:40
10
37:49
12
37:59
13
38:01
14
38:03
15
38:05
16 17
38:09
Por fim 18
38:13
execut Tá.
38:17
E bom, ya, tenho aqui nada tá a aparecer
38:19
como tá tudo igual. OK, agora vamos
38:22
fazer as alterações.
38:25
Desculpa, essa aqui é o agora vamos
38:27
fazer as alterações.
38:30
Se parar aqui no 7 89 asterisco. Depois
38:34
disso, o que vem?
38:36
Hum. 7 8 9 vamos ter 4 5 6 4 5 6.
38:44
4 5 6 4 5 6
38:48
7 8 9
38:52
4
38:55
5
38:58
6
38:59
aqui que esqueci o acho que é subtração,
39:02
se não me engano. Salvar.
39:07
E a 4 5 6 subtração quê? 1 2 3 adição. 1
39:12
2 3. Adição.
39:16
1
39:19
2
39:21
3 e por fim adição.
39:26
Salvar. E depois disso temos aqui é o
39:29
zero.
39:31
Será? Deixa-me controlar.
39:33
Eh, 0 ponto i igual
39:39
0,
39:41
desculpa ponto
39:43
e por fim
39:46
o sinal de igualdade que salvar. E se eu
39:49
executar nada irá mudar, será tudo
39:51
igual.
39:55
Ya, como ver aqui, tá tudo igual. Agora
39:56
vamos descair os botões para aqui
39:58
podemos apresentá-lo. Bem, isto vai ser
40:05
então aqui parei no 052
40:09
e o próximo será, deixa-me ver, deixa
40:11
meter aqui para para poder alterar tudo
40:14
de uma só vez.
40:16
E depois de 52 vai nos dar,
40:19
deixa-me ver,
40:22
104, será?
40:25
Executar.
40:28
OK, perfeitamente. Desceu muito bem. 1 2
40:30
3 4 5 6. Agora vamos descair mais um
40:33
pouquinho esse essa parte aqui. Depois
40:37
do 104 vai nos dar quanto? Deixa-me ver.
40:40
Isso é fácil. 156. Ó meu Deus. 156.
40:45
156.
40:48
Ya. Depois disso.
40:50
Ah, ok. Muito bem. Descaiu 156.
40:54
Temos 7 8 9 4 5 6 1 2 3. Agora essa
40:58
parte aqui, isso aqui deve descair para
41:00
aqui. Então 156 + 52.
41:05
156
41:07
+ 528.
41:12
Hum. Acho que é muito essa distância.
41:15
218.
41:18
Então, OK. Então aqui vai ser 2008.
41:22
Salvar, executar
41:26
e OK. Muito bem. Tá aqui. Obtivemos o
41:28
resultado que nós gostaríamos.
41:31
Todo tudo já está aqui pronto. E tem
41:34
aqui esse aqui, essa largura que está
41:36
muito grande que descaiu. Então aqui
41:39
vamos alterar um pouquinho a largura do
41:41
nosso
41:43
da nossa janela. Melhor dizer, desculpa,
41:45
da nossa janela. Então aqui
41:49
bem largura assim comprimenta a nossa
41:51
janela. Então aqui temos 118 em vez de
41:55
18 vamos tentar 10 salvar, executar.
42:01
Ya, muito bem, aquela parte já não temos
42:03
aqui. Foi. Ya, tá tudo aqui bonito. E
42:06
assim já terminamos o desenho da nossa
42:10
calculadora. Mas só que tá a faltar
42:12
alguma coisinha que é apresentamos aqui
42:15
o resultado
42:17
quando nós iremos executar as nossas
42:20
funções.
42:22
Então para para
42:25
a parte que irá apresentar as nossas
42:27
funções dizer aqui os nossos números
42:30
quando clicamos. Então isso aqui vai
42:31
ser, temos que criar um label, vir aqui
42:34
em cima depois do criando botões,
42:38
vou meter aqui
42:40
criando label.
42:43
Salvei cair para label vou pôr app
42:49
label
42:51
e vai ser igual a irei chamar o a classe
42:54
label irei abrir e o label que irá que
42:57
apresentar o resultado terá que ser aqui
42:59
na tela. Então ele vai passar para
43:01
dentro do frame tela. Ser frame tela.
43:05
Frame tela. Dá espaçozinho.
43:10
Eh, para o texto, por enquanto, irei
43:12
para um texto simples.
43:15
H,
43:16
OK. Irei pô um texto, por exemplo, 1 2 3
43:19
4 5 6 7 8 9 suficiente.
43:23
E depois disso, darei alguma largura de
43:27
16. Acho que vai ser o suficiente para
43:28
cobrir toda a tela. E depois disso, a
43:32
altura,
43:34
a altura da nossa tela que nós demos
43:35
aqui é de 50. Então aqui para ser texto
43:38
da aratura de dois é suficiente.
43:42
E depois disso darei uma pausinha aqui
43:45
up pap label vai ser igual aqui como
43:52
desculp não vai ser igual vai ser bom
43:55
aqui como eu havia dito vou usar o place
43:57
porque o place é muito mais simples que
43:59
eu usei em relação grid e o p então aqui
44:01
vai ser x vai ser igual x vai ser igual
44:04
a zer e o
44:07
y será igual a zer também salvar
44:11
e vou executar.
44:14
Ya, como podemos aqui, temos aqui o
44:16
nosso label que é que vamos de criar,
44:18
temos aqui o resultado. Então, vamos
44:20
expandir um pouquinho mais o label para
44:22
que ele possa ter essa toda a parte para
44:24
que possa ocupar toda essa toda essa
44:26
parte aqui. Então, isto vai ser vamos
44:28
fazer algumas alterações aqui para
44:29
dentro do nosso label. D um espaçozinho.
44:33
Então, vamos definir o padx
44:38
pading. Pad o peding e darei uns set é
44:42
muito. Vou dar uns setvar
44:45
e executar o que terei.
44:48
Ya, é suficiente. E padex quer dizer o
44:52
peding para este label aqui dentro dele.
44:56
E aqui depois disso aqui vou definir o
44:58
estilo desta label. Mas dá o estilo de,
45:01
deixa-me ver, desculpa. Rel
45:04
vai ser flat. Quero tudo liso.
45:09
Eh, como estas talvez sem parede
45:10
deficiência e maiúsculas. E o e o
45:13
resultado aqui, se formos a ver, deixa
45:15
deixa-me mostrar.
45:18
Como podemos ver aqui, este resultado
45:19
aqui, ele está a apresentar o resultado
45:20
no meio da tela. Então, quero que o
45:22
resultado, como nós sabemos, a
45:23
calculadora, normalmente ele mostra o
45:25
resultado aqui na parte mais à direita
45:28
da tela. Então para isso então teri que
45:30
fazer isso aqui o anchor
45:34
anchor irei para o i que é o est este e
45:40
aqui é o desculpa. Então depois disso
45:43
vou salvar para mostrar o resultado.
45:46
E como podemos ver agora aqui tá vendo?
45:47
Passou aqui o resultado na parte mais
45:49
direita da nossa tela. Se você notar
45:52
bem, se ve aqui, aqui eu tenho o último
45:55
número nove, até aqui no fim desse label
45:57
tem um espaçozinho. Esse espaço aqui é
45:59
aqui que nós demos aqui o pad X, que
46:02
demos um espaço de set da começar do
46:06
princípio e até onde vai terminar ou
46:08
melhor ou começar a letra. Então vai dar
46:10
tipo uma margem de S.
46:14
Depois daqui vou aumentar mais uma outra
46:16
propriedade que vai ser o justify.
46:22
Justify, que é quase a mesma coisa com o
46:23
anchor. Aqui vou pôr o
46:26
para meter tudo na direita. E deixa
46:30
executar para como sempre para mostrar o
46:32
resultado. Ya, ele passa tudo na
46:34
direita. E depois disso vamos vou
46:36
definir a fonte. Em vez de escrever mais
46:39
já tem já aqui a fonte escrita. Vou
46:41
simplesmente copiar.
46:45
Virei aqui e colar. É, espero que possam
46:49
ver. Ya, coli aqui a nossa fonte.
46:54
Se eu salvar e executar vai nos vamos
46:56
ter o quê? Ya, tem aqui ficou um
46:58
pouquinho mais grande. Então, em vez de
47:02
este número aqui é muito pequeno, vamos
47:03
aumentar um pouquinho o tamanho.
47:06
Uns 18. Deixa-me ver como quanto é que
47:08
eu tirei.
47:10
Ya, aqui agora está o label ocupou toda
47:12
essa parte aqui. O tamanho aqui deu 18.
47:16
E aqui em vez de bolt tá muito feio.
47:20
Vamos tirar o bol para ver o que vamos
47:21
ter.
47:24
OK. Deu um número mais pequeno que é um
47:26
número mais amigável, posso se dizer.
47:30
E também só que aqui a nossa tela, como
47:32
dizemos aqui, o fundo deve ser cor azul.
47:35
Então vamos também dar o a cor do fundo
47:37
que é o BG. Então virei aqui no fundo
47:40
mesmo. Opa, o BG igual. E a cor da tela
47:45
aqui que vai ser que cor? Deixa-me ver.
47:48
Frente tela que é cor. Ok. Score 3 que
47:51
nós definimos.
47:53
Vou fechar isso aqui.
47:56
PG.
47:58
Vou deixar fechar isso.
48:02
SBG
48:04
passa igual a
48:07
cor
48:09
test aqui. Se eu salvar, executar.
48:15
Muito bem. Tá aqui o nosso fundo já tá e
48:18
azul carregado e que tá bonito e a letra
48:20
deve ser branca. Então para a letra já
48:23
sabemos que é o FG que é o foring drain
48:26
of.
48:27
Então isso vai ser FG que vai ser igual
48:30
a para a cor branca igual que nós
48:33
definimos
48:34
eh branca é cor dois. Muito bem. É,
48:38
deixa-me fechar isso aqui para possamos
48:40
ver melhor.
48:44
Então vai ser cor
48:47
do cor do tá aí. Salvei e vou executar.
48:53
E bum. Prontos. temos aqui
48:57
onde vai aparecer o nosso resultado.
48:59
Vamos comparar com
49:04
temos aqui e vamos lá ver na no nosso
49:06
guia
49:08
aqui no nosso guia temos temos aqui esse
49:10
resultado para que já obtivemos
49:12
após obtemos esse resultado que nós
49:14
tanto queríamos e agora deixa-me ver
49:16
aqui na etapa seis após todas as
49:18
configurações, agora cria lógica para a
49:19
sua calculadora, define que tipo de
49:21
operações você vai realizar com ela e no
49:24
final tenta obter algo parecido com a
49:26
imagem abaixo, que é essa aqui. OK,
49:29
desculpa. Então, este resultado aqui nós
49:30
já obtivemos.
49:33
Agora vamos criar lógica que irá nos
49:35
permitir fazermos as operações para essa
49:37
calculadora. Então aqui nessa
49:38
calculadora aqui nós iremos executar
49:40
operações como divisão, multiplicação e
49:43
subtração, adição. E aqui por último que
49:46
este aqui que é o módulo que nos dá como
49:49
o resultado o resto de uma operação de
49:51
divisão. Então isto aqui vai ser vai ser
49:54
desse jeito. Viremos aqui desculpa,
49:57
viremos aqui para dentro da nossa
49:58
calculadora.
50:02
OK. Muito bem. Para executarmos os
50:04
nossos cálculos, aqui iremos usar o
50:06
EVAL, que é uma expressão em Python que
50:09
nos permite executar expressões que que
50:12
é passada para dentro dela. Então, para
50:14
exemplificar isso aqui, irei mostrar,
50:15
deixa-me ver, irei criar uma algumas
50:18
variáveis, vamos lá ver. Ah, por
50:20
exemplo, vou criar uma variável a vai
50:22
ser igual a val desse jeito aqui, abrir
50:25
e fechar. E aqui dentro dela, se eu
50:28
passar algumas expressões matemática,
50:29
ela irá executá-la. Então, deixa-me ver.
50:31
Vou tentar, por exemplo, uns 9 + 8 + 2.
50:36
É, se fizemos isso aqui, vai nos dar 9 +
50:38
8, acho que é 17 + 2, fica 19, se não me
50:42
engano. OK. Salvar isso. E se eu
50:44
imprimir isto aqui, deixa ver. Print.
50:49
Salvar.
50:50
Vamos imprimir para ver qual resultado.
50:57
Ya. Então, nós vemos aqui, tem aqui o
50:59
resultado nos deu 19. Então essa
51:01
expressão aqui vale, ele nos permite
51:02
executar expressões que são passadas
51:04
nela. Então, OK? Muito bem. Então, em
51:06
vez de
51:08
desse aqui, vamos ter vamos para uma
51:09
outra expressão, por exemplo, eh, nove
51:11
que divide nove que divide por nove,
51:15
acho que todo mundo sabe que vai nos dar
51:17
um e se eu executar, puxar um pouquinho
51:21
mais para cima.
51:22
Eh, como resultado tá aqui nos nos deu
51:25
1.0 que é certo, então iremos usar essa
51:28
expressão aqui para efetuarmos essa
51:30
calculadora. OK? Então isto aqui vai nos
51:33
vai nos dar o que nós vamos fazer aqui
51:35
primeiramente é criar uma função que
51:38
será passadas a todas as expressões
51:39
aqui. Então isto vai ser def.
51:44
Vou comentar aqui. Criando função.
51:46
Criando função.
51:50
Então aqui vai ser
51:53
def. Vai ser vou chamar def. calcular,
51:59
abrir e fechar, porque ele irá receber
52:02
algum valor do gênero. E desculpa, dois
52:06
pontos.
52:08
Irei passar isso aqui, essa expressão
52:10
aqui para dentro dela.
52:13
Faço isso
52:18
e aqui também. Tá. Agora, se eu executar
52:21
essa função aqui, deixa-me ver como
52:23
pular.
52:27
calcular.
52:32
Ele deve nos dar esse resultado aqui.
52:33
Então vamos lá ver. Executar.
52:40
OK. Nos deu o nosso resultado que nós
52:42
gostaremos aqui 1. Que é 1.0. Muito bem.
52:47
OK.
52:48
Após aqui, agora que nós devemos fazer é
52:50
arranjar um um método ou um meio de
52:53
passarmos os valores que serão aqui
52:56
apresentar nesses botões que quando
52:58
clicarmos no botões queremos que esses
52:59
valores sejam passado aqui para dentro
53:01
dessa expressão. Mas antes de tudo,
53:03
primeiramente devemos fazer que com que
53:05
esses valores aqui ao digitarmos
53:07
apareçam aqui na nossa tela. Então para
53:10
isso aqui iremos fazer o seguinte. Essa
53:12
toda expressão aqui, vamos tirá-la
53:15
daqui. Iremos passar para aqui em cima,
53:19
aqui por por debaixo dos frames
53:23
aqui. Faço isso. Colo, irei colar essa
53:26
parte calcular. Acho que já não acho que
53:28
irei manter ainda. E aqui aqui o app
53:31
label iremos tirar este labro aqui,
53:34
passar aqui para dentro do da nossa
53:36
função. Em vez de imprimirmos, iremos
53:39
passar esse valor aqui para dentro dessa
53:41
tela aqui do label. Então isto vai ser
53:44
ou desculpa, isto vai ser em vez de
53:47
imprimirmos esse sai. Eh, vou comentar
53:50
passando
53:53
valor
53:55
para passando valor para tela. Então
53:57
isto vai ser, devemos pegar o nome do do
54:01
label que nós queremos passar o valor.
54:02
Então vai ser app label
54:06
ponto
54:08
set eh abrir parente. E vamos fazer esse
54:12
valor aqui que vai nos dar o resultado
54:15
desse aqui. Então vai ser que vai ser
54:16
igual a a.
54:18
Então aqui em vez de a vou pôr
54:21
resultado.
54:24
E esse aqui também vai ser resultado.
54:32
OK. Muito bem. Então esse aqui em vez
54:35
disso aqui, aqui vou deixar em branco.
54:40
E agora vou executar para ver o que nós
54:42
iremos ter.
54:50
Ya, como podemos aqui nós obtivemos
54:52
algum erro que é name error name app
54:55
label not define. Obsertivemos esse erro
54:57
aqui por causa de, se formos ver aqui o
55:00
cirk quando ele vai executar vai indo
55:02
linha linha por linha porque nós sabemos
55:04
o python ele executa as suas o seu corpo
55:07
linha por linha. Então ele vai executar
55:09
aqui a função calcular, não vai fazendo
55:10
nada. Quando ele chegar aqui, vai
55:12
executar essa parte aqui, calcular e já
55:14
não vai chegar de fazer leitura dos
55:15
restantes códigos. Então, o restante
55:17
código aqui vai ser considerado como
55:19
algo que não foi criado ou que não
55:20
existe. Então, para isso teremos que ter
55:22
calcular aqui, sai daqui, vem aqui no
55:25
fim
55:26
onde tem todos os corpos e simplesmente
55:29
quer iremos executar, tá? Depois disso,
55:30
vamos salvar e executar.
55:34
OK? Então, após disso, nos deu mais
55:37
algum eh algum resultado que é o label
55:41
objetas no atribut set. Ele aqui nos deu
55:44
esse valor por causa do de uma seguinte
55:48
coisa. Então, se nós se nós gostarmos de
55:50
usar o set para alterar o valor de uma
55:53
label, primeiramente devemos criar a
55:57
alguma variável, alguma variável que
56:00
recebe eh valor de string. Então isso
56:03
aqui podemos resolver fazendo o
56:05
seguinte.
56:07
Então isso vai ser, vou chamar de valor
56:09
texto.
56:10
Desculpa, valor texto
56:15
e vai ser igual a
56:18
string string var desse jeito aqui. Esse
56:21
string var aqui, ele irá receber o valor
56:24
em string que será passado para esse
56:26
texto aqui. String var. Ok. Muito bem.
56:29
Irei salvar. E agora aqui e agora aqui o
56:33
texto, em vez de receber texto, não vai
56:36
receber texto, vai receber o tex
56:38
variável. Texto variável, que este aqui,
56:41
porque texto variável é uma variável que
56:43
permite
56:45
que permite que os valores dele sejam
56:47
alterados dinamicamente. Então o texto
56:49
variável vai ser, vamos passar esse
56:50
valor aqui que é o nosso valor texto,
56:53
vamos dar o valor
56:55
desse jeito aqui e salvar. Então, após
56:58
disso aqui,
57:01
agora vou tentar executar para ver o que
57:02
nós temos e se vamos obter algum erro ou
57:05
não. Caso obtivos algum erro, vamos
57:07
tentar entender o porque que nós obtemos
57:09
aquele erro e caso não, vamos
57:11
prosseguir. OK. Muito bem. Vem aqui,
57:14
executei
57:16
e de novo obtive algum erro. Então aqui
57:18
está de novo label object no atributo
57:21
set mesmo um erro. Ok? Então isto aqui
57:26
vamos descar aqui. Então depois de
57:27
fazermos isso aqui, o valor texto,
57:29
devemos vir aqui, devemos vir aqui para
57:32
dentro da nossa função. Em vez de
57:34
alterarmos o valor do label, vamos
57:36
alterar o valor desta desta variável
57:38
aqui, que o valor texto. Então aqui e
57:41
vamos chamar este valor texto aqui,
57:43
porque o resultado que nós queremos, ou
57:45
melhor, o o o valor deve ser introduzida
57:48
para dentro deste valor aqui e este
57:50
valor aqui ser apresentado aqui dentro
57:52
deste label. Então aqui em vez de
57:54
chamarmos o label vamos chamar a a
57:57
variável que nós criamos. Então isto
57:58
aqui vai ser o valor
58:01
valor texto.7 safá e vamos executar
58:06
para ver se vamos obter o mesmo erro ou
58:08
não.
58:10
Ya, como podemos ver aqui já não estamos
58:12
a ter o erro que nós estávamos a ter. E
58:14
aqui sabemos que a divisão de 9 por 9 dá
58:17
1. Aqui está aqui passou o resultado
58:18
para aqui dentro da nossa tela. Então
58:20
essa parte aqui já está concluída.
58:25
Agora aqui,
58:27
como nós sabemos, aqui não estamos a
58:29
calcular nada. Então aqui em vez de
58:30
chamamos calcular vamos chamá-la de
58:33
entrar. Essa função vai se chamar de
58:35
entrar. Entrar valores desse jeito aqui,
58:39
desculpa,
58:41
desse jeito aqui. Entrar valores.
58:44
Então agora aqui vamos lá aqui embaixo.
58:46
Em vez de deixar essa função calcular,
58:47
vamos simplesmente deletá-la e salvar.
58:51
Muito bem.
58:53
Eh, fecha isto.
58:55
OK, já temos aqui a nossa função entrar
58:57
valores, que irá nos permitir entrar
58:59
valores para dentro deste deste label
59:02
aqui. OK. Muito bem. Agora, o que nós
59:04
devemos fazer ou melhor que nós queremos
59:07
obter é que quando nós clicamos,
59:09
deixa-me executar para explicar melhor,
59:18
agora nós queremos que quando nós
59:20
clicamos em qualquer em um botão, por
59:24
exemplo, se eu clicar em set, eu quero
59:25
que este set apareça aqui na tela.
59:26
Então, para isso aqui, isto vai ser do
59:29
seguinte da seguinte maneira.
59:33
OK. Então vir aqui primeiramente no
59:35
primeiro botão, não, o primeiro botão
59:36
como é C, que é clean, que é para
59:38
limpar, não tem muito efeito. Então vir
59:40
aqui no segundo botão que é esse aqui.
59:45
Então nesse botão aqui eu virei aqui
59:47
atrás dele. Então isso aqui eu posso
59:49
meter aqui no fundo, mas como aqui no
59:51
fundo não teria uma visibilidade melhor,
59:54
então virei mesmo aqui no princípio
59:55
atrás dessa variável de texto aqui da
59:57
propriedade de texto, eh vou vou fazer
1:00:00
vou escrever vou entrar o seguinte aqui,
1:00:03
vou pôr vou escrever o seg vou escrever
1:00:05
o seguinte, comando.
1:00:07
Comand desse jeito aqui em inglês,
1:00:09
commandula,
1:00:11
desculpa. E aqui o que eu quero é que
1:00:14
quando eu clico nesse botão, ele o seu
1:00:16
valor apareça na tela. Então, para isso
1:00:18
que se nós queremos que o valor apareça
1:00:20
na tela, o que nós devemos alterar esta
1:00:22
variável aqui, o valor valor texto. Essa
1:00:24
este valor texto aqui irá conter todos
1:00:27
os valores que serão apresentada na na
1:00:29
nossa tela. Então o que eu tenho que
1:00:31
fazer é alterar o valor que será e que
1:00:34
será conterida neste nesta variável
1:00:36
aqui. Então aqui venho aqui, como eu
1:00:38
disse, havia dito, vou ver command, vou
1:00:41
meter aqui o valor test ou desculpa,
1:00:43
não. Ya, vou meter o valor text.
1:00:47
fazer isso e
1:00:50
salvar.
1:00:52
Ah, aqui
1:00:55
salvar. Então, muito bem. Então, vou
1:00:56
executar aqui para ver o que nós vamos
1:00:58
obter e depois de explicar.
1:01:05
OK, eu fiz isso aqui. Então, aqui foi
1:01:07
aqui onde nós passamos o comando. Se eu
1:01:09
clicar, nós veremos que nada será
1:01:13
apresentado aqui. Estás a ver? Se eu
1:01:15
clicar na então se eu quero que este
1:01:17
cada vez que eu clico aqui o valor
1:01:18
apareça aqui, então aqui
1:01:22
aqui eu estou tentando alterar esse
1:01:24
valor dessa variábola aqui. Então
1:01:25
simplesmente assim isto não dará certo.
1:01:26
Então o que eu tenho que fazer aqui é
1:01:28
usar a função lambda. A função lambda
1:01:30
nos permite executarmos códigos numa
1:01:32
solinha. Então para isso aqui, para eu
1:01:35
obter o resultado desejado, eu tenho que
1:01:36
fazer desta maneira aqui. Lambda lambda
1:01:38
desse jeito. Lambda e dois pontos. Aí
1:01:42
sim, vou usar aquela variável que é o
1:01:46
entrar, desculpa, que é o entrar,
1:01:50
entrar valores. E esse entrar valores
1:01:53
aqui, essa entrada de valores aqui,
1:01:56
aqui, isso aqui não é essa variável
1:01:57
aqui, valor texto. Essa entrar valor
1:01:59
aqui é essa função aqui que eu estou a
1:02:01
chamar aqui, a função entrar valores.
1:02:03
Então essa função aqui, aqui dentro irei
1:02:06
passar algum o valor que eu desejo que
1:02:08
seja apresentada para dentro da tela.
1:02:10
Então aqui entrar valores,
1:02:13
se temos aqui essa função aqui, ele não
1:02:14
recebe nenhum parâmetro. Então aqui
1:02:16
vamos passá-lo um parâmetro para que
1:02:17
possa ser executada. Então aqui vai ser
1:02:20
podemos passar qualquer letra aqui.
1:02:22
Então vou meter um event.
1:02:25
Isso aqui pode ser qualquer nome porque
1:02:26
ele vai receber algum valor e depois vai
1:02:29
ser executado aqui dentro. Então aqui no
1:02:31
event aqui no evento, como havia dito,
1:02:35
ele vai vai receber algum parâmetro.
1:02:37
Então o parâmetro aqui que ele vai
1:02:38
receber será esse texto aqui, que é o
1:02:42
valor deste botão. Então aqui vai ser o
1:02:46
percentagem e vai ser dentro de parêntes
1:02:48
como string, vai ser o percentagem.
1:02:52
Vou fazer isso e salvar. Então agora dis
1:02:54
depois disso aqui eu vou executar para
1:02:56
ver que o que vamos obter. Fiz isso
1:02:59
aqui, chamei. Deixa-me fechar. Executar
1:03:02
de novo.
1:03:08
Ok. Muito bem. Tenho aqui. Se eu clicar
1:03:10
aqui de novo, estás a ver? Ele só tá
1:03:12
apresentar 1.0. Se eu clicar de novo,
1:03:14
ele vai apresentar sempre o mesmo
1:03:15
resultado. Mesmo resultado, mesmo
1:03:16
resultado. Então, o que eu tenho que
1:03:18
fazer é o seguinte
1:03:22
aqui, depois de eu passar esse valor
1:03:23
aqui, este valor aqui para dentro da
1:03:25
nossa função entrar valores, então ele
1:03:28
aqui receber este valor. Então, só que
1:03:31
esse valor aqui ele deve ser armazenado
1:03:32
em algum local. Então, então este valor
1:03:35
aqui, esse valor aqui eventá
1:03:39
armazenada para dentro de uma variável
1:03:41
comum. Então essa variável aqui ele vai
1:03:43
chamá-la de todos
1:03:47
valores desse jeito aqui e todos os
1:03:49
valores vai ser igual a esse todos os
1:03:51
valores aqui, ele vai receber este valor
1:03:53
que vai ser introduzido a nela. Então
1:03:55
vai ser igual a,
1:03:57
desculpa, vai ser igual a event. Esse
1:03:59
evento aqui é este valor que irá receber
1:04:01
aqui.
1:04:03
Então depois de eu receber todos os
1:04:05
valores aqui, então aqui no valor texto,
1:04:08
que é essa variável aqui que apresenta o
1:04:10
valor na tela. Então, irei passá-la o
1:04:13
nosso valor que é o todos
1:04:17
valores. Vou fazer isso e salvar. Depois
1:04:19
disso, como sempre, vou executar para
1:04:21
ver o nosso resultado.
1:04:25
OK. Feito isso, tirei aqui. Então, vou
1:04:27
clicar de novo aqui para ver o que eu
1:04:29
tenho. Ya, cliquei, apareceu aqui ele.
1:04:32
Cliquei, apareceu. Cliquei, apareceu.
1:04:34
Então aqui só que há um erro. Cada vez
1:04:36
que eu clico, ele só apresenta
1:04:38
simplesmente um único valor. Tá ver? vai
1:04:39
apresentando o mesmo valor, o mesmo
1:04:41
valor, o mesmo valor. Então eu quero que
1:04:42
cada vez que ele clica, ou melhor, cada
1:04:44
vez que eu clique, ele vai acrescentando
1:04:46
mais percentagem, percentagem,
1:04:48
porcentagem, porcentagem até que, sei
1:04:51
lá, até onde até onde dê. Então, para
1:04:53
isso aqui, para que ele não esteja a
1:04:56
apresentar sempre o mesmo valor, o que
1:04:58
nós devemos fazer é o seguinte.
1:05:02
Devemos criar uma variável que irá
1:05:04
receber cada vez que nós clicamos no
1:05:06
valor, aquela variável será irá
1:05:08
armazenar todos os valores que serão
1:05:09
clicada, que depois disso esses valores
1:05:13
iremos simplesmente apresentá-la para
1:05:14
dentro da nossa tela. Então para isso
1:05:16
aqui vamos definir uma variável que vai
1:05:19
receber todos esses valores aqui. Então
1:05:21
essa esses valores aqui, então isto vai
1:05:22
ser da seguinte maneira. Então aqui
1:05:24
temos aqui a a variável todos os
1:05:26
valores. Então essa variável de todos os
1:05:27
valores vamos torná-lo vamos torná-la
1:05:29
global. Então, como é global, então isso
1:05:32
vai ser todos
1:05:35
valores
1:05:37
em vez daqui aqui em frente vamos meter
1:05:40
global
1:05:42
aqui. Vamos determinar essa essa
1:05:43
variável aqui todos os valores como uma
1:05:45
variável global. Vou salvar. OK. Após
1:05:49
definir o todos os valores como global,
1:05:51
o mesmo também iremos criar de novo uma
1:05:54
outra variável aqui aqui fora da nossa
1:05:57
função. Por exemplo, aqui por cima. Eh,
1:06:00
vamos definir a mesma o a mesma variável
1:06:02
como todos os valores. Vamos todos os
1:06:04
valores vai ser igual a uma string
1:06:07
vazia. Desse jeito aqui fica assim dessa
1:06:10
maneira. Eh, deixa eu ver. variável
1:06:13
variável
1:06:17
todos os valores
1:06:20
todos os valores.
1:06:22
Essa essa variável aqui todos os valores
1:06:25
aqui dentro da função será chamada como
1:06:27
todos os valores também, mas será
1:06:29
definida como global. Então o que que
1:06:30
quer dizer que qualquer alteração que
1:06:32
nós fizemos nesse nessa valor aqui valor
1:06:35
ela será mantida. Não importa em que
1:06:37
local ela será chamada. o valor não será
1:06:39
alterada, mas sim será eh reusado.
1:06:42
Então, para depois disso aqui, depois de
1:06:44
nós chamando todos os valores, aqui
1:06:45
dentro da função, iremos definir-la como
1:06:47
global para que podemos acessar os
1:06:49
valores dessa variável aqui. E depois
1:06:52
disso aqui, então agora aqui como
1:06:54
resultado vamos deletar essa parte aqui,
1:06:57
já não nos interessa.
1:06:59
Agora aqui o todos os valores vai ser
1:07:01
igual a
1:07:04
todos
1:07:06
de novo todos os valores mais
1:07:09
aqui o event que é essa parte aqui e str
1:07:13
vamos vamos definir como string
1:07:18
como string aqui o str deferida como
1:07:20
string e aqui o resultado acho que o
1:07:26
resultado aqui vai continuar sempre
1:07:29
É, é vale qualquer expressão. Vamos lá
1:07:30
ver 9 por 9 mesmo. Vamos manter.
1:07:36
Hum. Fica dentro de string. OK. É vale
1:07:38
no por OK. Então aqui vai ter então
1:07:41
todos os valores. Tá vendo?
1:07:45
Então essa vábula aqui todos os valores
1:07:47
é uma string que vai ser do gênero.
1:07:50
Então cada vez que nós entramos aqui,
1:07:52
por exemplo, se eu entrar aqui este
1:07:54
valor, esse valor aqui ele será aqui
1:07:57
virá aqui no evento e a variável todos
1:07:59
os valores aqui, ele vai ser atribuída a
1:08:02
esse valor aqui. O event será dentro
1:08:05
para será atribuída para dentro desse
1:08:07
valor aqui. Então isso quer dizer que o
1:08:08
valor que irá contém aqui nesta variável
1:08:11
todos valores será
1:08:13
eh será feita a concatenização dela com
1:08:17
o valor que será passada para essa
1:08:19
função aqui entrar valores. Então tu
1:08:22
vais ele vai juntando todas as
1:08:24
expressões que será atribuída para essa
1:08:26
função aqui para dentro dessa para
1:08:29
dentro dessa variável aqui todos os
1:08:30
valores. Então vai fazer sempre a
1:08:31
concatenização. Por exemplo, se eu
1:08:33
entrar o número um, ele vai meter um,
1:08:35
vai guardar um para dentro dessa
1:08:36
variável aqui. Se eu entrar número dois,
1:08:38
ele vai meter também dois para dentro
1:08:40
da, então vai ser tipo um, dois. Se eu
1:08:42
meter tipo mais, então vai ser 1 2 mais.
1:08:45
E ok, deixa ver. 1 2 mais. Se eu entrar
1:08:48
de novo um outro valor vai ser, por
1:08:50
exemplo, se eu entrar nove, vai ser
1:08:51
nove. Se eu entrar nove de novo, vai ser
1:08:53
nove. 9. Se eu entrar tipo um outro
1:08:55
valor de novo, por exemplo, se eu meter
1:08:57
multiplicação, vai ser multiplicação.
1:08:59
Cada vez que eu vou entrando valores,
1:09:01
ele vai sempre juntando, vai fazer
1:09:02
concatização desses valores que vão
1:09:05
entrando. Porque aqui, como sabemos, o
1:09:06
Eval, ele executa expressões que estão
1:09:09
passadas por ele. E se nós passamos essa
1:09:11
expressão aqui, criando o quê? Se nós
1:09:14
passamos essa essa expressão aqui, o 12
1:09:16
+ 999 para dentro deste deste val aqui.
1:09:21
Isso aqui sabemos que é uma expressão
1:09:22
válida. Então aqui o Eval poderá
1:09:24
executar essa expressão. Então agora
1:09:27
aqui
1:09:29
aqui em vez de
1:09:32
executarmos aquilo aí
1:09:34
aqui iremos executar
1:09:37
o resultado que será que iremos obter
1:09:40
aqui na variável todos os valores. Então
1:09:41
aqui para oival vai ser todos
1:09:45
valores que ele deve executar a
1:09:47
expressão que será guardada para dentro
1:09:48
de todos os valores e vamos apagar isso
1:09:50
que fica vazio. Aqui fica assim.
1:09:53
resultado que será evaluado aqui. Então
1:09:56
aqui se eu deixa-me ver salvar.
1:10:01
OK, vamos executar. Deixa-me ver.
1:10:06
Hum.
1:10:09
Ok. Se eu clicar aqui, ã, s tá. Oh,
1:10:12
desculpa, acho que cometi um erro. Sim.
1:10:15
OK. Aqui depois de entrarmos valores
1:10:17
aqui o resultado não vamos não, nós não
1:10:19
vamos executar essa expressão, é vamos
1:10:21
simplesmente aletá-la. Essa parte já não
1:10:24
precisamos porque nós queremos é que
1:10:26
esses valores aqui seja apresentada para
1:10:27
dentro da tela. Então aqui todos os
1:10:29
valores vai ser aqui vai ser passada
1:10:32
para aqui o valor tex que é o string var
1:10:34
e para ser apresentada na tela. Então
1:10:36
vou salvar
1:10:37
e fazer isso. Vamos lá ver que vamos
1:10:39
ter.
1:10:43
Então aqui vou clicar aqui. Meteu aqui o
1:10:46
percentagem. Clicar de novo. Meteu
1:10:48
percent ele vai acrescentando mais vai
1:10:50
acrescentando valores, valores, valores,
1:10:52
valores. E a parte que eu expliquei que
1:10:55
havia dito aqui que onde vamos executar,
1:10:58
evaluar a expressão todos os valores,
1:11:00
isso aqui vai ser para dentro de uma
1:11:02
outra função. Então já obtivemos essa
1:11:03
parte aqui, a parte que nós queríamos,
1:11:06
que é
1:11:08
obter as expressões que nós iremos
1:11:10
clicar. que é obter os valores quando
1:11:12
nós clicar num num dos botões. Deixa
1:11:16
mostrar mais uma vez.
1:11:18
Temos aqui clicando, clicando, ele vai
1:11:21
adicionando, vai adicionando, vai
1:11:22
adicionando, vai adicionando e tudo isso
1:11:24
aqui será armazenado aqui para essa
1:11:26
variável aqui. Todos os valores, tudo
1:11:28
será está ser guardando aqui, está ser
1:11:30
guardado aqui. OK? Muito bem. Então
1:11:33
agora o que já fizemos aqui para esse
1:11:35
botão aqui iremos fazer para os
1:11:37
restantes dos botões. Então para isso
1:11:39
simplesmente vir aqui. Eu vou copiar até
1:11:42
aqui,
1:11:44
ó. Vou atrás do texte.
1:11:47
Acho que vou copiar também com a
1:11:48
vírgula.
1:11:50
Copiei. Vou atrás do texte e meter
1:11:53
todos.
1:11:54
Todos.
1:11:57
Hum.
1:11:59
Vou selecionando
1:12:01
de novo. De novo, de novo, de novo,
1:12:07
de novo, de novo, 19.
1:12:14
E sinal da igualdade. Não precisamos por
1:12:17
enquanto vou pôr
1:12:19
e fazer isso. Ya,
1:12:24
vou salvar agora aqui. Em vez disso, vai
1:12:27
ser o ponto.
1:12:30
Aqui vai ser o zero.
1:12:33
Hum. Aqui vai ser esse aqui.
1:12:37
Aqui terá que ser o três.
1:12:41
Aqui terá que ser o dois. Aqui terá que
1:12:44
ser o um.
1:12:46
Aqui terá que ser isso aqui. Subtração.
1:12:50
Vai ser seis.
1:12:53
Vai ser cinco.
1:12:56
Hum. Que que vamos ter o quatro?
1:13:01
Desculpa vocês.
1:13:08
Oito. E por fim temos o nosso sete e
1:13:11
divisão.
1:13:15
Ya, salva. Vamos lá executar para ver o
1:13:20
nosso resultado como sempre.
1:13:25
OK. Muito bem. Vamos lá testar. Se eu
1:13:26
clicar em set, OK, obtivemos o set 8 9.
1:13:30
Esse aqui deu certo. Deu certo. 4 5 6
1:13:35
subtação - 1 2 3 1 0 1. Ok, já estamos a
1:13:42
já estamos a obter os nossos valores e
1:13:44
agora vamos arranjar um método de pegar
1:13:48
todos esses valores aqui e calcular.
1:13:50
Então, para isso aqui vai ser simples,
1:13:51
como já havia, como havíamos dito, então
1:13:54
será simples. Aqui a variável todos os
1:13:56
valores, ela irá acumular todas as
1:13:59
expressões que nós iremos passar para a
1:14:00
calculadora. Então, para isso, vamos
1:14:02
criar uma nova função que irá executar
1:14:05
ou melhor que irá evaluar todos
1:14:08
caráteros que serão guardados para
1:14:09
dentro dessa variável aqui, todos os
1:14:10
valores. Então, para isso aqui, aqui
1:14:13
vamos ter o def, vamosar uma nova função
1:14:18
para calcular o quê?
1:14:20
função
1:14:24
para calcular
1:14:27
função para calcular. Então aqui essa
1:14:30
variável aqui criando variável
1:14:33
esse vou lerar daqui sai daqui ele p
1:14:36
aqui por cima o próximo desta próximo
1:14:39
desta outra variável para ser mais fácil
1:14:41
de controlá-las
1:14:43
ok e agora aqui de vamos criar uma
1:14:46
função que será a função para calcular
1:14:48
calcular
1:14:51
calcular
1:14:53
abrir e fechar dois pontos
1:14:55
aqui vamos lá pôr vamos criar uma
1:14:57
variável Vamos chamar de resultado
1:15:02
vai ser igual a
1:15:05
equival
1:15:07
abrir e fechar
1:15:10
todos os valores.
1:15:14
Ele aqui vai evaluar toda a expressão
1:15:16
que será executada aqui para dentro do
1:15:18
que. Então depois disso aqui vai ser o
1:15:21
print.
1:15:22
Por enquanto vou imprimir resultado.
1:15:26
Resultado.
1:15:28
Vamos imprimir esse resultado aqui que
1:15:30
vamos obter dessa operação aqui.
1:15:33
Resultado. Resulado. Resultad. OK.
1:15:36
Resultado.
1:15:38
E eu devo calcular.
1:15:44
E o def calcular aqui não tá fazer não
1:15:46
tá sendo nada. Para executamos essa
1:15:47
função aqui calcular, teremos que vir
1:15:49
aqui no igual, aqui onde temos a a
1:15:53
expressão igual. Queremos que quando nós
1:15:54
clicamos igual ele executa aquela função
1:15:57
lá. Então para isso aqui isso vai ser
1:16:00
igual a aqui vai se apagar isso. Não é
1:16:02
necessário usarmos lambda, vai ser
1:16:04
simplesmente calcular desse jeito aqui.
1:16:06
Calcular.
1:16:09
OK? Então cada vez que nós clicamos no
1:16:11
igual ele irá executar esta função aqui.
1:16:13
Agora vamos testar como sempre.
1:16:17
Vamos lá ver se obtivemos algum erro,
1:16:19
vamos tentar corrigir. Caso não, como
1:16:20
sempre iremos prosseguir.
1:16:23
OK? Então temos aqui, vamos tentar uma
1:16:25
expressão simples. 1 + 1. 1 + 1 dá
1:16:27
quanto? Acho que dá dois. OK. Vamos
1:16:30
tentar agora clicar na expressão aqui no
1:16:33
nosso igual para ver. OK. Aqui
1:16:37
conseguimos 1 mais um. Deu dois. Tá aqui
1:16:39
obtivemos dois. E se eu clicar o nove,
1:16:44
ele juntou em vez de deletar o seguinte,
1:16:47
se eu clicar no 9, deu 20. Então isso
1:16:49
praticamente 1 + 9 é iges
1:16:53
0, tudo deve dar zero, não? E vai dar 1.
1:16:57
Então isso aqui é 1 + 19 x 0.
1:17:00
Primeiramente vai executar a
1:17:01
multiplicação, depois vai executar a
1:17:03
adição. Então 19 x 0 1 + eh 1 + 0 é
1:17:07
igual a 1. Tá aqui. Obemos essa
1:17:09
expressão aqui. Agora nós queremos que
1:17:10
cada vez que nós clicamos aqui na função
1:17:14
igual, ela irá demonstrar o resultado,
1:17:17
mas terá que deletar aqui o terá que
1:17:20
deletar as toda a expressão que estiver
1:17:22
dentro da nossa tela. Então para isso,
1:17:24
vamos vamos lá ver como podemos fazer
1:17:27
isso.
1:17:29
OK. Para isso aqui, vamos criar uma
1:17:31
função, chama, vamos chamar de limpar
1:17:33
tela, ok? Eh, função
1:17:37
limpar tela.
1:17:40
Então, aqui vai ser F,
1:17:43
eh, limpar a tela. Vou chamar de limpar
1:17:45
tela mesmo. Def, limpar tela.
1:17:48
Abrir e fechar. Faço isso. E aqui de
1:17:52
limpar tela que nós devemos limpar é
1:17:54
essa variável aqui todos valor, todos os
1:17:56
valores. Nós queremos que essa variá
1:17:58
aqui todos os valor seja vazia. Então
1:18:00
para isso vou chamar o todos os valores.
1:18:03
Todos os valores fazer isso desculpa,
1:18:05
todos os valores vai ser igual a string
1:18:08
vazia. Desse jeito aqui.
1:18:11
Todos os valores, isso aqui deve estar
1:18:13
vazio.
1:18:15
E o aqui esta vela aqui, o valor set que
1:18:19
é a tela, nós devemos também alterá-lo.
1:18:22
Então vai ser valor
1:18:25
valor set eh vai ser igual a
1:18:29
como sempre
1:18:31
todos
1:18:33
não, em vez de p todos os valores, vamos
1:18:36
simplesmente deixar vazio. valor ponto
1:18:39
set
1:18:41
vai ser igual a string vazi desse jeito
1:18:44
aqui.
1:18:45
Aqui para limpar é aqui no C, neste C
1:18:48
aqui, nesse botão C. Então aqui vai
1:18:50
vamos ter o command.
1:18:54
Comand vai ser igual a limpar limpar
1:18:58
tela
1:19:00
e ya desse jeito aqui mesmo. Limpar tela
1:19:02
salvar. Agora vamos executar para ver o
1:19:04
que vamos ter.
1:19:08
Desculpa.
1:19:10
Então, se eu vir aqui, vou clicar 7 x 8,
1:19:15
nos deu 7 x 8 56. Tá aqui o resultado,
1:19:17
56. E se eu clicar aqui, deve ele deve
1:19:20
apagar isso aqui e
1:19:23
também limpar a variável todos os
1:19:25
valores. Então, cliquei aqui, tá vendo?
1:19:26
Deletou tudo, apagou. Se eu meter de
1:19:28
novo eh 1
1:19:32
+ 1, tá ver? deste conta aqui, o 7 x 8
1:19:37
manteu, não apagou e o mais um também
1:19:39
foi adicionado. Se eu clicar, de certeza
1:19:42
o valor será alterado 50 568.
1:19:45
Então isto aconteceu porque, como havia
1:19:48
dito aqui, temos aqui todos os valores.
1:19:51
Então, se nós queremos que tudo que nós
1:19:54
eh fizemos com essa variável aqui, todos
1:19:56
os valores eh seja também mantida em
1:19:59
todas as funções que têm essa variabel
1:20:01
de todos os valores. Então, para cada
1:20:03
dentro dessas para dentro dessas funções
1:20:05
aqui também devemos decar declarar esta
1:20:07
variável todos os valores como uma
1:20:08
variável global. Então isto aqui vai ser
1:20:12
global
1:20:14
todos.
1:20:17
global todos os valores. Então, desse
1:20:19
jeito aqui, qualquer alteração que eu
1:20:21
fizer com esse valor aqui, todos os
1:20:22
valores também será alterada para dentro
1:20:24
dessas funções aqui para ou melhor será
1:20:27
também alterada para qualquer local em
1:20:29
que este esta variável aqui todos os
1:20:31
valores esteja localizado.
1:20:33
Então, o mesmo também terei terei que
1:20:35
fazer aqui para dentro da nossa função
1:20:37
calcular.
1:20:39
Vou definir de novo global todos
1:20:43
valores, porque aqui também no global
1:20:45
nós também usamos o todos os valores.
1:20:47
Então, após disso, vamos lá ver agora.
1:20:49
Vamos testar para ver o que nós vamos
1:20:50
ter. Se eu fazer isso,
1:20:56
OK, virei aqui. Vou lá pôr o set.
1:21:02
7 x 5. Se eu fazer 7 x 5, 35. Tá aqui,
1:21:06
nos deu 35. Se eu clicar aqui no C para
1:21:08
deletar, deletou. Vamos clicar de novo.
1:21:11
1 + 1. Ok. Tá a ver? Deu conta aqui. E o
1:21:16
7 x 5 foi limpado. Praticamente já não
1:21:18
existe. Agora o que tá o que mantém aqui
1:21:21
que existe aqui agora é o 1 + 1. Se eu
1:21:23
clicar tá aqui nos deu o nosso resultado
1:21:25
que 1 + 1 é igual a 2. Clicar de novo,
1:21:28
limpar. Desapareceu. Vamos lá ver. 9 x 3
1:21:33
= 27. Ya, agora tudo já tá a funcionar
1:21:36
normalmente. E agora só que tem um erro
1:21:38
que está nos a escapar. Cada vez que nós
1:21:41
clicamos aqui no sinal igual de
1:21:43
igualdade, em vez dele apresentar aqui o
1:21:45
resultado, ele está apresentado aqui no
1:21:47
nosso terminal. Então, agora nós
1:21:49
queremos que esse resultado aqui saia
1:21:50
daqui e seja apresentado aqui para
1:21:52
dentro da nossa calculadora. Então, para
1:21:54
isso aqui, vamos fazer o seguinte,
1:21:58
OK? Então, isso vai ser aqui, o problema
1:22:01
está aqui para dentro da função
1:22:02
calcular. Então aqui dentro da função
1:22:04
calcular, em vez de imprimirmos, vamos
1:22:06
fazer isso aqui. Sai.
1:22:08
Vamos pegar o nosso valor, como sempre,
1:22:12
o valor test. Valor test.
1:22:16
Vou abrir e fechar a todos.
1:22:20
Este é todos os valores que é isso aqui.
1:22:23
OK. Em vez de dep simplesmente todos os
1:22:25
valores, vou lhe eh converter em string.
1:22:27
OK.
1:22:28
vou lhe converter em string ou melhor
1:22:30
dizer em vez de todos os valores deve
1:22:32
ser resultado, porque aqui o resultado
1:22:33
que vai conter o resultado da operação.
1:22:35
Então em vez de todos os valores, ya,
1:22:37
muito bem mesmo. Isso vai ser resultado.
1:22:41
OK. Saber muito bem que o resultado é
1:22:42
uma string, mas só para evitar erros,
1:22:45
vamos p um str de resultado. Converter
1:22:50
ela de novo em swing, tanto faz. OK.
1:22:53
Depois disso, vamos salvar e executar
1:22:54
para ver o que vamos ter. Ok,
1:23:01
muito bem. Temos aqui o, vamos lá tentar
1:23:04
agora o 7,
1:23:07
uma operação mais simples feita. 7 + 1,
1:23:10
que é igual a 8, vai nos dar, se eu dar
1:23:12
a ver, meteu aqui 7 + 1 = 8, já não está
1:23:15
mais imprimir aqui e está agora a
1:23:17
apresentar aqui. Vou limpar isso aqui.
1:23:20
Vamos lá agora. 7 - 7 é 0. tá aqui nos
1:23:25
deu zero e limpar. Vamos lá, vamos
1:23:29
testar agora essa operação aqui que é eh
1:23:32
2 que divide 2
1:23:35
L é 2 módulo 2. Módulo 2. Módulo dois
1:23:39
significa que se nós fizemos 2 que
1:23:41
divide por 2 é igual a 1 resto zero.
1:23:46
Então isso aqui deve nos dar a zero
1:23:48
porque a divisão entre dois e que divide
1:23:51
dois não dá nenhum resto, é zero. Se eu
1:23:53
clicar talvez de o zero. Agora, se eu
1:23:55
fizer uma divisão de, por exemplo, o
1:23:57
modo de quatro
1:24:00
ou acho que obtivemos aqui algum erro,
1:24:03
acho que todo mundo deu conta que
1:24:06
e já não limpou, então acho que vou
1:24:08
limpar mesmo. Vou limpar aqui sozinho.
1:24:10
Vou fazer o quatro
1:24:13
que divide.
1:24:14
Se eu fizer, por exemplo, um quatro que
1:24:16
divide três, 4 que divide três acho que
1:24:18
vai nos restar a um. OK, vamos lá ver.
1:24:22
OK, 4/ 3 e resta um. que tá aqui de
1:24:25
resultado como
Science

