0:00:00.000,0:00:03.970
Agora que você já conhece[br]as estruturas condicionais em Portugol,

0:00:03.970,0:00:07.050
vamos ver na prática[br]como é feito no Python.

0:00:14.857,0:00:17.734
Para executar um código em Python,[br]existem várias formas.

0:00:17.734,0:00:19.255
Você pode instalar[br]na sua máquina

0:00:19.255,0:00:22.468
e executar com sua[br]ferramenta predileta,

0:00:22.468,0:00:24.791
ou podemos usar alguma[br]plataforma online.

0:00:24.791,0:00:28.415
Aqui estou no[br]"online-python.com",

0:00:28.415,0:00:30.745
uma plataforma que você[br]consegue executar códigos

0:00:30.745,0:00:34.534
rapidamente[br]na linguagem Python.

0:00:34.534,0:00:36.970
Eu tenho um[br]algoritmo implementado

0:00:36.970,0:00:41.574
onde nós vamos ver o uso do[br]"if" e "else" da estrutura condicional.

0:00:41.574,0:00:45.163
Primeiramente,[br]dentro dessa variável "idade",

0:00:45.163,0:00:47.857
nós estamos pedindo para[br]o usuário digitar uma idade,

0:00:47.857,0:00:51.758
transformando o que ele digitou,[br]quem vem em uma string,

0:00:51.758,0:00:53.853
em um número inteiro.

0:00:53.853,0:00:57.857
Depois, fazemos a validação[br]através do "if".

0:00:57.857,0:01:01.828
Aqui, a condição que eu quero,[br]"idade >= 18".

0:01:01.828,0:01:04.813
No final do "if",[br]eu tenho que colocar os ":"

0:01:04.813,0:01:08.985
e essa identação[br]é obrigatória

0:01:08.985,0:01:12.438
para entender[br]o que está dentro do "if".

0:01:12.438,0:01:16.743
No caso, somente esse "print"[br]com um texto para o usuário.

0:01:16.743,0:01:19.540
Então, eu tenho também[br]o comando "else", com ":",

0:01:19.540,0:01:23.963
e também o recuo para dizer que[br]o "print" está dentro do "else",

0:01:23.963,0:01:27.920
ou seja, se essa condição for[br]verdadeira, ele vai imprimir.

0:01:27.920,0:01:29.589
"Você pode assistir os vídeos";

0:01:29.589,0:01:33.121
se condição[br]"idade >= a 18" for falsa,

0:01:33.121,0:01:36.162
ele vai imprimir[br]esse outro texto.

0:01:36.162,0:01:39.565
Clicando no "Run", eu vou[br]conseguir executar esse código.

0:01:39.565,0:01:42.859
Então, eu vou digitar uma idade,[br]uma idade de 20

0:01:42.859,0:01:44.950
e, no caso,[br]o acesso foi concedido,

0:01:44.950,0:01:48.241
ou seja, ele imprimiu o que[br]está dentro do "if".

0:01:48.241,0:01:51.897
Se eu colocar uma idade[br]menor do que 18,

0:01:51.897,0:01:55.581
ele vai executar[br]o que está no "else".

0:01:55.581,0:01:59.668
Aqui no Python, eu tenho[br]os operadores relacionais também.

0:01:59.668,0:02:01.687
Então, eu tenho o "and".

0:02:01.687,0:02:08.194
Eu poderia colocar "idade <= 60",[br]ou "idade < 60",

0:02:08.194,0:02:14.834
ou seja, eu tenho a condição[br]idade >= 18 e idade < 60,

0:02:14.834,0:02:17.570
ele tem que atender[br]a essas duas condições

0:02:17.570,0:02:20.106
para que este texto[br]seja impresso.

0:02:20.106,0:02:23.709
Então, se eu executar aqui[br]e colocar 70 anos, agora,

0:02:23.709,0:02:25.208
ele não vai ter[br]a permissão,

0:02:25.208,0:02:29.782
porque essa condição aqui[br]se tornou falsa.

0:02:29.782,0:02:34.120
Além do "and", eu tenho "or",[br]que seria um ou outro,

0:02:34.120,0:02:37.590
então ou a idade é maior,[br]igual ou idade menor,

0:02:37.590,0:02:41.394
e eu tenho a negação,[br]também, seria o "not".

0:02:41.394,0:02:46.098
Então, no caso, ele está invertendo[br]o resultado dessa condição.

0:02:46.098,0:02:47.407
Se isso aqui[br]for verdadeiro,

0:02:47.407,0:02:50.431
o "not" vai transformar[br]essa expressão no falso;

0:02:50.431,0:02:53.739
e se for falso,[br]ele transforma em verdadeiro.

0:02:53.739,0:02:58.051
Esses são os nossos operadores[br]relacionais dentro do Python.

0:02:58.051,0:03:01.847
É possível trabalhar, também,[br]com "if" encadeado dentro do Python.

0:03:01.847,0:03:05.751
Porém, no Python existe[br]uma estrutura chamada "elif",

0:03:05.751,0:03:07.626
que é a junção do[br]"else" com o "if",

0:03:07.626,0:03:09.422
onde eu coloco já[br]uma condição,

0:03:09.422,0:03:11.390
ficando um código[br]muito mais simples.

0:03:11.390,0:03:12.494
Vamos ver na prática.

0:03:12.494,0:03:16.062
Aqui eu tenho um algoritmo[br]onde nós estamos validando

0:03:16.062,0:03:19.899
a premiação dos clientes[br]de acordo com o valor de compras

0:03:19.899,0:03:22.735
e também a frequência[br]que ele está realizando as compras.

0:03:22.735,0:03:25.264
Então, primeiramente,[br]nós estamos armazenando

0:03:25.264,0:03:27.757
nesta variável chamada[br]"valor_compras"

0:03:27.757,0:03:31.510
o valor total das compras[br]do nosso cliente;

0:03:31.510,0:03:34.046
e aqui na "frequencia"[br]nós pedimos para ele colocar

0:03:34.046,0:03:38.484
quantas vezes ele realizou[br]uma compra na nossa loja.

0:03:38.484,0:03:43.422
Essa aqui é do tipo float[br]e a "frequencia" do tipo inteiro.

0:03:43.422,0:03:44.890
Então,[br]começam as validações:

0:03:44.890,0:03:51.455
se "valor_compras >=2000.0"[br]e a "frequencia >=10",

0:03:51.455,0:03:54.500
ele vai ter aqui[br]a categoria VIP.

0:03:54.500,0:03:59.103
E então, o nosso "elif"[br]ou seja, o "else" junto com "if"

0:03:59.103,0:04:02.641
e esse "if" já vem[br]com a nova condição.

0:04:02.641,0:04:05.433
Então,[br]se essa expressão for falsa,

0:04:05.433,0:04:09.548
ele vai vir para o "elif" e vai[br]testar essa nova condição aqui.

0:04:09.548,0:04:14.520
Se essa aqui também for falsa,[br]ele vai para o próximo e o "elif",

0:04:14.520,0:04:17.377
testando aqui se[br]"valor_compras > 500"

0:04:17.377,0:04:19.492
ou "frequencia >5",

0:04:19.492,0:04:22.595
e se essa condição[br]não for verdadeira,

0:04:22.595,0:04:26.098
as duas expressões aqui[br]com "or' forem verdadeiras,

0:04:26.098,0:04:28.808
ele vai para o "else"[br]para imprimir

0:04:28.808,0:04:32.738
essa última mensagem[br]para o nosso usuário.

0:04:32.738,0:04:34.573
Vamos testar?

0:04:34.573,0:04:42.173
Então, no caso o "valor_compras",[br]eu comprei 1000 reais

0:04:42.173,0:04:44.516
e eu realizei 6 compras[br]no ano.

0:04:44.516,0:04:47.753
Aonde será que ele vai?

0:04:47.753,0:04:51.190
Qual "if" ou "elif"[br]que ele vai executar?

0:04:51.190,0:04:56.061
Então, aqui deu que eu estou na[br]categoria ouro e ganhei prêmios extras,

0:04:56.061,0:05:01.066
ou seja, se olhar aqui,[br]"valor_compras" é maior do que 1000,

0:05:01.066,0:05:04.470
maior ou igual, senão não teria[br]entrado aqui nessa condição.

0:05:04.470,0:05:07.632
Então ele validou a primeira,[br]viu que não foi verdadeira,

0:05:07.632,0:05:11.977
já que eu só fiz[br]1000 de valor e 6

0:05:11.977,0:05:14.917
e ele caiu aqui[br]nesse próximo e "elif".

0:05:14.917,0:05:19.151
Outra estrutura condicional existente[br]no Python, a partir do 3.10,

0:05:19.151,0:05:23.498
é o "match case", é o equivalente[br]ao "switch case" em outras linguagens.

0:05:23.498,0:05:26.933
Eu quero saber qual é o valor[br]que existe dentro da variável.

0:05:26.933,0:05:28.976
Se eu tenho um conjunto[br]de valores possíveis

0:05:28.976,0:05:31.897
e, dependendo do valor,[br]eu quero executar alguns comandos,

0:05:31.897,0:05:35.203
eu posso utilizar essa[br]estrutura condicional.

0:05:35.203,0:05:39.038
Aqui eu tenho um algoritmo que está[br]implementando uma calculadora,

0:05:39.038,0:05:42.282
onde o usuário tem 4 opções

0:05:42.282,0:05:44.801
e ele vai escolher a opção[br]de acordo com um número.

0:05:44.801,0:05:49.194
Então, 1 é soma, 2 é subtração,[br]3 é multiplicação e 4 é divisão

0:05:49.194,0:05:51.388
e, de acordo com esse menu[br]que foi apresentado,

0:05:51.388,0:05:53.302
ele vai escolher[br]uma das opções,

0:05:53.302,0:05:58.323
que será armazenadas[br]nesta variável chamado "escolha".

0:05:58.323,0:06:00.793
Depois, nós vamos ler[br]outros 2 números,

0:06:00.793,0:06:04.062
que serão realizados na[br]operação aritmética que ele escolheu,

0:06:04.062,0:06:08.534
então, vão ser armazenado[br]no "num1" e no "num2".

0:06:08.534,0:06:10.636
Então, nós vamos[br]calcular o resultado.

0:06:10.636,0:06:12.600
Como que vamos[br]calcular o resultado?

0:06:12.600,0:06:16.208
De acordo com o que ele[br]escolheu aqui nessa opção.

0:06:16.208,0:06:18.203
Então,[br]"match (escolha):",

0:06:18.203,0:06:21.947
o que tiver dentro dessa variável[br]chamada "escolha",

0:06:21.947,0:06:25.517
Se for 1, ele vai executar[br]esses comandos;

0:06:25.517,0:06:32.772
se for 2, esses outros;[br]3 essa multiplicação;

0:06:32.772,0:06:38.953
e se for 4, primeiro ele valida[br]se "num2" é diferente de 0,

0:06:38.953,0:06:41.033
já que eu não posso[br]dividir por 0.

0:06:41.033,0:06:45.337
Se for diferente, ele vai realizar[br]a divisão e mostrar o resultado;

0:06:45.337,0:06:49.174
se não for, ele vai falar que[br]"Não é possível dividir por zero!".

0:06:49.174,0:06:53.979
Esse último case,[br]quando colocamos esse "_",

0:06:53.979,0:06:58.417
quer dizer que nenhuma das opções[br]foram atendidas, ou seja,

0:06:58.417,0:07:02.910
o "escolha" que o usuário digitou[br]não é o número 1, 2, 3 ou 4,

0:07:02.910,0:07:05.057
ou seja, qualquer outro[br]valor que ele digitou,

0:07:05.057,0:07:08.115
então, nós temos aqui um "case"[br]que é uma ação padrão,

0:07:08.115,0:07:10.429
que vai realizar que é[br]"Operação inválida!".

0:07:10.429,0:07:14.466
Então, vamos testar,[br]vou dar o "Run".

0:07:14.466,0:07:17.007
Ele deu um erro aqui,[br]falando que na linha 20

0:07:17.007,0:07:22.240
tem um problema "Match (escolha)",[br]sintaxe inválida.

0:07:22.240,0:07:25.510
Provavelmente isso aconteceu[br]por causa da versão do Python,

0:07:25.510,0:07:30.949
onde não existe essa estrutura[br]ainda na versão escolhida.

0:07:30.949,0:07:33.685
Então, vou procurar por[br]uma outra plataforma online

0:07:33.685,0:07:35.320
para executarmos[br]o nosso código.

0:07:35.320,0:07:41.126
Então, vou escrever "python online",[br]ou pesquisar aqui,

0:07:41.126,0:07:45.697
Vou usar essa GDB online,[br]que aqui eu consigo executar

0:07:45.697,0:07:48.645
várias linguagens de programação,[br]inclusive o Python

0:07:48.645,0:07:52.604
na versão aqui que[br]aceita o "match case".

0:07:52.604,0:07:55.540
Então, eu vou copiar[br]o código anterior

0:07:55.540,0:08:00.479
e colocar aqui nessa nova plataforma[br]e vou dar o "Run.

0:08:00.479,0:08:02.080
Maravilha, funcionou.

0:08:02.080,0:08:06.585
Então, no caso eu vou[br]escolher a soma,

0:08:06.585,0:08:11.656
vou colocar o número 5 e o número 6[br]e o resultado da soma foi 11,

0:08:11.656,0:08:15.393
ou seja, como eu coloquei o valor 1,[br]fiz a escolha 1,

0:08:15.393,0:08:18.763
ele executou este "case"[br]com o valor 1.

0:08:18.763,0:08:24.369
Vou testar agora com uma opção[br]que não existe, não é 1, 2, 3 ou 4.

0:08:24.369,0:08:26.705
Vou colocar 9,[br]por exemplo,

0:08:26.705,0:08:29.670
e vou colocar 2 números[br]quaisquer aqui

0:08:29.670,0:08:31.717
e ele vai mostrar[br]"Operação inválida!",

0:08:31.717,0:08:35.019
ou seja, o "escolha",[br]como tinha o valor 9,

0:08:35.019,0:08:38.751
não era nem o 1, 2, 3 ou 4,[br]ele veio aqui para o último,

0:08:38.751,0:08:41.193
que é o "case" padrão[br]que nós temos.

0:08:41.193,0:08:44.256
Com isso nós vimos as estruturas[br]condicionais no Python,

0:08:44.256,0:08:49.470
o "if", "else", o "elif" e, também,[br]a nova versão com o "match case".