WEBVTT

00:00:18.750 --> 00:00:19.498
Parâmetros ajudam a gente

00:00:19.498 --> 00:00:20.425
a modular o comportamento
de uma função,

00:00:20.425 --> 00:00:21.568
e a gente já sabe como
definir parâmetros simples,

00:00:21.568 --> 00:00:22.839
que são informados
de forma posicional,

00:00:22.839 --> 00:00:24.178
e parâmetros 
de quantidade dinâmica,

00:00:24.178 --> 00:00:25.517
em que a gente consegue 
lidar com eles

00:00:25.517 --> 00:00:26.139
como se fosse uma coleção qualquer.

00:00:26.139 --> 00:00:28.088
Chegou a hora da gente ver 
como lidar com parâmetros

00:00:28.088 --> 00:00:29.380
que podem ou não virem
para a nossa função.

00:00:29.380 --> 00:00:31.317
O que a gente vai ver
agora são chamados KWARGs,

00:00:31.317 --> 00:00:33.267
ou Keyword Arguments, 
que são argumentos

00:00:33.267 --> 00:00:35.198
que a gente passa 
no formato de dicionário.

00:00:35.198 --> 00:00:37.130
E para que eles servem?

00:00:41.790 --> 00:00:44.250
Imagina que você tem que trabalhar
com a função que você tem

00:00:44.250 --> 00:00:45.480
um valor específico que tem
que ser informado.

00:00:45.480 --> 00:00:47.265
Nesse cenário, você informa para ele 
um parâmetro simples,

00:00:47.265 --> 00:00:49.962
que sempre vai estar lá, 
e que se não for informado,

00:00:49.962 --> 00:00:52.660
o Python dá um erro.

00:00:52.660 --> 00:00:54.592
Por outro lado, se você tem 
uma lista de quantidade dinâmica,

00:00:54.592 --> 00:00:56.534
a gente vai ter que usar os args,
para que a gente consiga manipular eles

00:00:56.534 --> 00:01:01.060
de forma dinâmica, sem se preocupar
com a quantidade total.

00:01:01.060 --> 00:01:04.735
No entanto, a gente pode querer
um parâmetro

00:01:04.735 --> 00:01:06.572
que vai estar ou não presente.

00:01:06.572 --> 00:01:08.410
Ou seja, ele é uma informação opcional.

00:01:08.410 --> 00:01:11.366
Se ele estiver presente, 
a gente faz alguma coisa com ele.

00:01:11.366 --> 00:01:14.545
Caso não, a gente não faz
ou assume algum valor padrão.

00:01:14.545 --> 00:01:18.102
E para isso, a estrutura de dados
mais adequada que a gente conhece

00:01:18.102 --> 00:01:19.135
é o dicionário,

00:01:19.135 --> 00:01:22.455
que é justamente o tipo entregue 
quando a gente usa os KWARGs.

00:01:22.455 --> 00:01:24.362
Então, agora, vamos
lá para o código e dar uma olhada

00:01:24.362 --> 00:01:26.270
em como esse cara funciona.

00:01:26.270 --> 00:01:27.951
Aqui no VS Code,

00:01:27.951 --> 00:01:28.791
a gente já tem 
um código de exemplo,

00:01:28.791 --> 00:01:30.805
que é uma função simples 
que exibe uma mensagem olá

00:01:30.805 --> 00:01:32.820
e algum nome que foi entregue.

00:01:32.820 --> 00:01:35.357
Se a gente exibir ela aqui,
executar ela, na verdade,

00:01:35.357 --> 00:01:37.508
com o comando do Python,

00:01:37.508 --> 00:01:39.660
a gente vai ver exatamente 
isso na tela.

00:01:39.660 --> 00:01:42.445
Mas, imagina que a gente queira
receber aqui a informação

00:01:42.445 --> 00:01:45.140
de se esse aluno 
fez ou não um trabalho prático.

00:01:45.140 --> 00:01:46.980
Então, a gente precisa
de uma informação

00:01:46.980 --> 00:01:49.075
que vai dizer para a gente,
na verdade,

00:01:49.075 --> 00:01:51.170
a nota que ele tirou
nesse trabalho prático.

00:01:51.170 --> 00:01:53.660
E se ele não tiver uma nota, 
não significa que ele tirou zero.

00:01:53.660 --> 00:01:56.150
Significa que ele não entregou.

00:01:56.150 --> 00:01:57.115
Tá bom?

00:01:57.115 --> 00:01:58.080
Então, vamos começar com isso.

00:01:58.080 --> 00:02:01.340
A gente poderia definir
aqui duas variáveis.

00:02:01.340 --> 00:02:03.930
Uma para informar se ele fez
ou não um trabalho prático.

00:02:03.930 --> 00:02:05.755
E, para isso, a gente usaria 
o tipo booleano.

00:02:05.755 --> 00:02:08.415
E, depois, uma outra
para especificar a nota.

00:02:08.415 --> 00:02:09.792
Mas, como a gente 
consegue usar os KWARGs,

00:02:09.792 --> 00:02:11.911
a gente vai fazer isso 
de uma vez só,

00:02:11.911 --> 00:02:13.520
informando apenas a nota.

00:02:13.520 --> 00:02:15.130
Então, saca só.

00:02:15.130 --> 00:02:17.082
Eu vou colocar aqui
a minha outra variável,

00:02:17.082 --> 00:02:18.840
que vai ser o meu
outro parâmetro,

00:02:18.840 --> 00:02:25.060
que eu vou chamar
de informações adicionais.

00:02:25.060 --> 00:02:28.055
E, nesse caso, para que o Python
entenda que isso

00:02:28.055 --> 00:02:30.970
daqui é um QArgs e não
uma variável simples,

00:02:30.970 --> 00:02:33.124
eu vou ter que colocar
não um, mas, dessa

00:02:33.124 --> 00:02:35.340
vez, dois asteriscos
no começo dela.

00:02:35.340 --> 00:02:37.446
Então, pronto.
A partir de agora, se

00:02:37.446 --> 00:02:40.134
eu executar a aplicação
sem mexer na invocação

00:02:40.134 --> 00:02:42.389
ou no conteúdo daquela
função, o Python

00:02:42.389 --> 00:02:45.250
consegue executar isso
sem problema nenhum.

00:02:45.250 --> 00:02:47.841
Porque ele já entendeu
que isso se trata de um QArgs

00:02:47.841 --> 00:02:50.650
e que as informações que estão
ali, elas são opcionais.

00:02:50.650 --> 00:02:52.780
Ou seja, eu posso informar ou não.

00:02:52.780 --> 00:02:54.382
Se a gente vier
aqui dentro do bloco

00:02:54.382 --> 00:02:56.385
de código, vamos executar
um print com aquele

00:02:56.385 --> 00:02:58.188
valor, só para a gente
entender o formato

00:02:58.188 --> 00:03:00.080
que as coisas estão
chegando aqui dentro.

00:03:00.080 --> 00:03:04.860
Eu vou copiar o nome da variável e,
aqui, chamar a função nativa print,

00:03:04.860 --> 00:03:07.150
passando ela para a gente
ver ali no terminal.

00:03:07.150 --> 00:03:08.640
Eu vou executar mais uma vez.

00:03:08.640 --> 00:03:10.785
E repara que a mensagem
está aqui e que, aqui

00:03:10.785 --> 00:03:13.110
embaixo, dessa vez,
eu tenho um dicionário,

00:03:13.110 --> 00:03:16.900
que é aquela estrutura que a gente
usa baseada em chave e valor.

00:03:16.900 --> 00:03:19.328
Então, eu vou começar
aqui, na invocação

00:03:19.328 --> 00:03:22.171
do método, passando valores
para esse meu QArgs.

00:03:22.171 --> 00:03:26.800
E, para fazer isso, eu posso
passar eles no formato de chaves.

00:03:26.800 --> 00:03:28.389
Ou seja, eu tenho
que colocar o nome

00:03:28.389 --> 00:03:30.520
e o valor que eu quero
para aquela chave.

00:03:30.520 --> 00:03:32.385
No nosso caso,
vai ser a nota

00:03:32.385 --> 00:03:35.410
do trabalho prático,
ou seja, nota tp.

00:03:35.410 --> 00:03:38.054
Então, por isso, eu vou
colocar aqui nota tp,

00:03:38.054 --> 00:03:41.150
o sinal de igual e o valor
que eu quero informar.

00:03:41.150 --> 00:03:43.690
Que, nesse caso, vai
ser, por exemplo, 10.

00:03:43.690 --> 00:03:45.883
Eu vou só salvar o meu
programa e executar

00:03:45.883 --> 00:03:48.580
de novo para a gente
ver o que mudou.

00:03:48.580 --> 00:03:50.933
Aqui, a mensagem continua
a mesma coisa, só que,

00:03:50.933 --> 00:03:53.500
dessa vez, repara que dentro
do meu dicionário,

00:03:53.500 --> 00:03:57.080
eu tenho a chave
nota tp com valor 10.

00:03:57.080 --> 00:03:58.618
E, a partir daqui,
a gente já consegue

00:03:58.618 --> 00:04:00.250
trabalhar
com essa informação.

00:04:00.250 --> 00:04:02.395
E é exatamente isso que a gente
vai fazer aqui agora.

00:04:02.395 --> 00:04:04.101
Eu vou abrir um espacinho
entre as duas

00:04:04.101 --> 00:04:06.520
mensagens e uma coisa
que a gente tem que lembrar

00:04:06.520 --> 00:04:10.350
é que os QArgs são informações
realmente opcionais.

00:04:10.350 --> 00:04:12.407
Então, a gente tem
que lidar com o cenário

00:04:12.407 --> 00:04:14.240
delas estarem
presentes ou não.

00:04:14.240 --> 00:04:16.561
E a estrutura do dicionário
entrega formas

00:04:16.561 --> 00:04:19.450
de a gente lidar com isso
sem problema algum.

00:04:19.450 --> 00:04:21.340
Então, eu vou,
basicamente, antes de usar

00:04:21.340 --> 00:04:23.210
as informações
daquele dicionário,

00:04:23.210 --> 00:04:24.861
ver se tem alguma
informação dentro

00:04:24.861 --> 00:04:26.980
da chave que eu estou
pretendendo usar.

00:04:26.980 --> 00:04:29.360
Então, para isso, a nossa regra
vai ser a seguinte.

00:04:29.360 --> 00:04:31.498
Se a gente não tiver
aquela chave, significa

00:04:31.498 --> 00:04:33.680
que o aluno não Fez
o trabalho prático.

00:04:33.680 --> 00:04:35.451
E, por isso, eu vou,
basicamente, exibir

00:04:35.451 --> 00:04:37.810
uma mensagem falando
que a gente não encontrou tp.

00:04:37.810 --> 00:04:38.670
Vamos lá.

00:04:38.670 --> 00:04:42.548
Aqui dentro, eu vou começar
com uma condicional para que eu veja

00:04:42.548 --> 00:04:46.130
se a chave nota tp está
dentro daquela minha variável.

00:04:46.130 --> 00:04:49.914
Então, eu vou colocar
aqui entre aspas,

00:04:49.914 --> 00:04:53.540
nota tp em informações
adicionais.

00:04:53.540 --> 00:04:56.044
Ou seja, se aquela nota
estiver dentro daquelas

00:04:56.044 --> 00:04:59.340
informações, então esse bloco
de código vai ser executado.

00:04:59.340 --> 00:05:01.676
Mas como que eu quero
exatamente o contrário,

00:05:01.676 --> 00:05:04.260
eu vou colocar uma negação
aqui antes do in.

00:05:04.260 --> 00:05:06.000
Então, fica da seguinte forma.

00:05:06.000 --> 00:05:08.355
Se a chave nota tp
não estiver dentro

00:05:08.355 --> 00:05:10.985
do dicionário
informações adicionais,

00:05:10.985 --> 00:05:18.140
então eu quero exibir uma mensagem
falando que o tp não foi encontrado.

00:05:18.140 --> 00:05:21.960
E como, a partir daqui, eu não
quero executar mais nada,

00:05:21.960 --> 00:05:24.966
eu vou apenas escrever um return
para que o Python entenda

00:05:24.966 --> 00:05:28.170
que eu não tenho que executar
mais nada daqui para frente

00:05:28.170 --> 00:05:29.970
e saia dessa função.

00:05:29.970 --> 00:05:32.890
Vamos rodar aqui de novo
o nosso terminal.

00:05:32.890 --> 00:05:36.180
Ou melhor, limpar o terminal
e executar novamente a aplicação

00:05:36.180 --> 00:05:39.480
para a gente ver como que as coisas
se comportam do jeito que está.

00:05:39.480 --> 00:05:42.820
Desse jeito aqui, a aplicação
não entrou na condicional

00:05:42.820 --> 00:05:44.292
e seguiu adiante
exibindo aquele

00:05:44.292 --> 00:05:46.660
nosso dicionário
de informações adicionais.

00:05:46.660 --> 00:05:50.260
Mas se a partir de agora
eu remover essa informação,

00:05:50.260 --> 00:05:53.200
ele entra na condicional
e exibe a mensagem para a gente.

00:05:53.200 --> 00:05:55.975
Então eu vou voltar
com ela daqui para que a gente

00:05:55.975 --> 00:05:59.190
coloque mais coisa aqui
no fluxo do nosso programa.

00:05:59.190 --> 00:06:01.347
E a partir desse momento,
a gente está trabalhando

00:06:01.347 --> 00:06:03.870
com a possibilidade de que a nota
está sendo entregue.

00:06:03.870 --> 00:06:07.490
Então eu vou colocar um if para ver
se essa nota é maior do que 7.

00:06:07.490 --> 00:06:09.183
Se for, então o aluno
está aprovado.

00:06:09.183 --> 00:06:11.610
Se não for, então o
aluno está reaprovado.

00:06:11.610 --> 00:06:13.894
Então eu vou começar
com mais uma condicional

00:06:13.894 --> 00:06:16.355
e eu vou acessar
o informações adicionais

00:06:16.355 --> 00:06:19.750
e usar o método get
para pegar aquela chave.

00:06:19.750 --> 00:06:21.600
Qual que é a chave?

00:06:21.600 --> 00:06:22.950
a nota tp.

00:06:22.950 --> 00:06:26.430
Eu copio aqui e vejo se
ela é maior do que 7.

00:06:26.430 --> 00:06:30.210
Se ela for maior do que 7,
eu vou copiar aqui essa mensagem

00:06:30.210 --> 00:06:31.670
e eu vou editar para que ela seja.

00:06:33.740 --> 00:06:37.900
parabéns, você foi aprovado no tp.

00:06:37.900 --> 00:06:41.030
E eu também vou definir
um caso padrão, que é o Else,

00:06:41.030 --> 00:06:43.435
para quando essa condicional
não for atendida.

00:06:43.435 --> 00:06:46.190
E se esse for o caso,
eu vou exibir a mensagem.

00:06:48.500 --> 00:06:51.430
Infelizmente, você não
foi aprovado no tp.

00:06:51.430 --> 00:06:52.730
E pronto.

00:06:52.730 --> 00:06:56.240
Deixa eu só tirar essa mensagem
aqui de baixo, limpar o terminal,

00:06:56.240 --> 00:06:58.293
e se a gente executa
a nossa aplicação

00:06:58.293 --> 00:07:00.094
novamente, a gente
tem a mensagem

00:07:00.094 --> 00:07:04.240
Olá aluno, que a gente não mexeu,
e parabéns, você foi aprovado no tp.

00:07:04.240 --> 00:07:06.634
Se a gente abaixa
um pouco essa nota aqui,

00:07:06.634 --> 00:07:09.151
para algo próximo de 10,
mas um pouco abaixo

00:07:09.151 --> 00:07:11.856
de 7, por exemplo, 1,
a gente vai ter a mensagem

00:07:11.856 --> 00:07:14.720
Infelizmente, você não
foi aprovado no tp.

00:07:14.720 --> 00:07:17.715
E é dessa forma que a gente
consegue preparar as nossas funções

00:07:17.715 --> 00:07:21.090
para que elas consigam lidar
com informações opcionais, ou seja,

00:07:21.090 --> 00:07:24.190
que podem ou não serem formadas.

00:07:24.190 --> 00:07:26.957
Claro, a gente poderia
também lidar com informações

00:07:26.957 --> 00:07:29.630
do tipo se a variável
estiver com um valor vazio,

00:07:29.630 --> 00:07:32.218
ou se uma boleana estiver
informando algo, então

00:07:32.218 --> 00:07:35.460
eu posso assumir que uma outra
variável tem um valor.

00:07:35.460 --> 00:07:38.911
Mas está começando a ficar bem claro
que isso ficaria muito complicado

00:07:38.911 --> 00:07:42.480
de dar manutenção e até mesmo
de entender o que está acontecendo.

00:07:42.480 --> 00:07:45.850
E da mesma forma com que a gente
tem diversas estruturas de dados,

00:07:45.850 --> 00:07:47.890
a gente também tem
diversas possibilidades.

00:07:47.890 --> 00:07:50.727
Cada um atende um cenário
e cabe a gente a decidir qual

00:07:50.727 --> 00:07:53.310
que é a melhor para o nosso caso
de uso específico.