WEBVTT

00:00:07.864 --> 00:00:09.364
Parâmetros ajudam a gente

00:00:09.364 --> 00:00:11.314
a modular o comportamento
de uma função,

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

00:00:13.984 --> 00:00:16.344
que são informados
de forma posicional,

00:00:16.344 --> 00:00:18.434
e parâmetros
de quantidade dinâmica,

00:00:18.434 --> 00:00:19.774
em que a gente consegue
lidar com eles

00:00:19.774 --> 00:00:21.654
como se fosse uma coleção qualquer.

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

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

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

00:00:30.234 --> 00:00:33.394
ou Keyword Arguments,
que são argumentos

00:00:33.394 --> 00:00:36.024
que a gente passa
no formato de dicionário.

00:00:36.024 --> 00:00:37.454
E para que eles servem?

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

00:00:40.274 --> 00:00:42.714
um valor específico que tem
que ser informado.

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

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

00:00:48.444 --> 00:00:50.114
o Python dá um erro.

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

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

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

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

00:01:03.564 --> 00:01:05.654
que vai estar ou não presente.

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

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

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

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

00:01:17.764 --> 00:01:18.714
é o dicionário,

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

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

00:01:24.384 --> 00:01:26.154
em como esse cara funciona.

00:01:26.154 --> 00:01:26.974
Aqui no VS Code,

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

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

00:01:31.354 --> 00:01:32.324
e algum nome que foi entregue.

00:01:32.324 --> 00:01:35.484
Se a gente exibir ela aqui,
executar ela, na verdade,

00:01:35.484 --> 00:01:36.534
com o comando do Python,

00:01:36.534 --> 00:01:38.754
a gente vai ver exatamente
isso na tela.

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

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

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

00:01:46.994 --> 00:01:48.434
que vai dizer para a gente,
na verdade,

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

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

00:01:54.304 --> 00:01:55.974
Significa que ele não entregou.

00:01:55.974 --> 00:01:56.684
Tá bom?

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

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

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

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

00:02:05.634 --> 00:02:08.284
E, depois, uma outra
para especificar a nota.

00:02:08.284 --> 00:02:10.524
Mas, como a gente
consegue usar os KWARGs,

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

00:02:12.244 --> 00:02:13.924
informando apenas a nota.

00:02:13.924 --> 00:02:14.944
Então, saca só.

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

00:02:17.354 --> 00:02:18.354
que vai ser o meu
outro parâmetro,

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

00:02:24.964 --> 00:02:28.754
E, nesse caso, para que o Python
entenda que isso daqui é um KWARGs

00:02:28.754 --> 00:02:30.814
e não uma variável simples,

00:02:30.814 --> 00:02:33.014
eu vou ter que colocar
não um, mas, dessa vez,

00:02:33.014 --> 00:02:35.254
dois asteriscos
no começo dela.

00:02:35.254 --> 00:02:36.584
Então, pronto.

00:02:36.584 --> 00:02:38.884
A partir de agora,
se eu executar a aplicação

00:02:38.884 --> 00:02:42.214
sem mexer na invocação
ou no conteúdo daquela função,

00:02:42.214 --> 00:02:45.084
o Python consegue executar isso
sem problema nenhum.

00:02:45.084 --> 00:02:47.804
Porque ele já entendeu
que isso se trata de um KWARGs

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

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

00:02:52.704 --> 00:02:55.024
Se a gente vier aqui
dentro do bloco de código,

00:02:55.024 --> 00:02:56.794
vamos executar um print
com aquele valor,

00:02:56.794 --> 00:02:58.434
só para a gente entender
o formato que as coisas

00:02:58.434 --> 00:02:59.924
estão chegando aqui dentro.

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

00:03:04.704 --> 00:03:06.994
passando ela para a gente
ver ali no terminal.

00:03:06.994 --> 00:03:08.534
Eu vou executar mais uma vez.

00:03:08.534 --> 00:03:11.064
E repara que a mensagem
está aqui e que, aqui embaixo,

00:03:11.064 --> 00:03:12.974
dessa vez, eu tenho um dicionário,

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

00:03:15.804 --> 00:03:19.374
Então, eu vou começar aqui,
na invocação do método,

00:03:19.374 --> 00:03:22.354
passando valores
para esse meu KWARGs.

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

00:03:26.694 --> 00:03:29.174
Ou seja, eu tenho que colocar
o nome e o valor que eu quero

00:03:29.174 --> 00:03:30.414
para aquela chave.

00:03:30.414 --> 00:03:34.594
No nosso caso, vai ser a nota
do trabalho prático, ou seja, nota tp.

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

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

00:03:41.014 --> 00:03:43.534
Que, nesse caso, vai
ser, por exemplo, 10.

00:03:43.534 --> 00:03:46.524
Eu vou só salvar o meu programa
e executar de novo

00:03:46.524 --> 00:03:48.464
para a gente ver o que mudou.

00:03:48.464 --> 00:03:50.974
Aqui, a mensagem continua
a mesma coisa, só que,

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

00:03:53.424 --> 00:03:56.984
eu tenho a chave
nota tp com valor 10.

00:03:56.984 --> 00:03:57.634
E, a partir daqui,

00:03:57.634 --> 00:04:00.114
a gente já consegue trabalhar
com essa informação.

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

00:04:02.204 --> 00:04:04.484
Eu vou abrir um espacinho
entre as duas mensagens

00:04:04.484 --> 00:04:06.414
e uma coisa que a gente
tem que lembrar

00:04:06.414 --> 00:04:10.254
é que os KWARGs são informações
realmente opcionais.

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

00:04:11.904 --> 00:04:14.154
delas estarem presentes ou não.

00:04:14.154 --> 00:04:17.024
E a estrutura do dicionário
entrega formas

00:04:17.024 --> 00:04:19.484
de a gente lidar com isso
sem problema algum.

00:04:19.484 --> 00:04:20.624
Então, eu vou, basicamente,

00:04:20.624 --> 00:04:23.124
antes de usar as informações
daquele dicionário,

00:04:23.124 --> 00:04:25.384
ver se tem alguma informação
dentro da chave

00:04:25.384 --> 00:04:26.894
que eu estou pretendendo usar.

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

00:04:29.214 --> 00:04:30.924
Se a gente não tiver
aquela chave,

00:04:30.924 --> 00:04:33.584
significa que o aluno
não fez o trabalho prático.

00:04:33.584 --> 00:04:34.804
E, por isso, eu vou,
basicamente,

00:04:34.804 --> 00:04:37.744
exibir uma mensagem falando
que a gente não encontrou tp.

00:04:37.744 --> 00:04:38.594
Vamos lá.

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

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

00:04:45.524 --> 00:04:48.404
Então, eu vou colocar
aqui entre aspas,

00:04:48.404 --> 00:04:53.434
nota tp em informações
adicionais.

00:04:53.434 --> 00:04:56.854
Ou seja, se aquela nota estiver
dentro daquelas informações,

00:04:56.854 --> 00:04:59.214
então esse bloco de código
vai ser executado.

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

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

00:05:04.334 --> 00:05:05.834
Então, fica da seguinte forma.

00:05:05.834 --> 00:05:09.394
Se a chave nota tp
não estiver dentro do dicionário

00:05:09.394 --> 00:05:10.894
informações adicionais,

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

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

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

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

00:05:28.074 --> 00:05:29.864
e saia dessa função.

00:05:29.864 --> 00:05:32.784
Vamos rodar aqui de novo
o nosso terminal.

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

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

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

00:05:42.684 --> 00:05:45.834
e seguiu adiante exibindo aquele
nosso dicionário de informações adicionais.

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

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

00:05:53.034 --> 00:05:55.614
Então eu vou voltar com ela daqui
para que a gente coloque

00:05:55.614 --> 00:05:59.094
mais coisa aqui no fluxo
do nosso programa.

00:05:59.094 --> 00:05:59.924
E a partir desse momento,

00:05:59.924 --> 00:06:01.414
a gente está trabalhando
com a possibilidade

00:06:01.414 --> 00:06:03.254
de que a nota está sendo entregue.

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

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

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

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

00:06:13.284 --> 00:06:15.684
e eu vou acessar
o informações adicionais

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

00:06:19.764 --> 00:06:20.494
Qual é a chave?

00:06:20.494 --> 00:06:22.204
a nota tp.

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

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

00:06:29.584 --> 00:06:32.024
e eu vou editar para que ela seja.

00:06:32.024 --> 00:06:37.014
"Parabéns, você foi aprovado no tp".

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

00:06:40.874 --> 00:06:43.314
para quando essa condicional
não for atendida.

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

00:06:46.614 --> 00:06:50.754
"Infelizmente, você não
foi aprovado no tp".

00:06:50.754 --> 00:06:51.834
E pronto.

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

00:06:56.124 --> 00:06:57.954
e se a gente executa
a nossa aplicação novamente,

00:06:57.954 --> 00:06:59.634
a gente tem a mensagem

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

00:07:03.574 --> 00:07:06.124
Se a gente abaixa
um pouco essa nota aqui,

00:07:06.124 --> 00:07:07.664
para algo próximo de 10,

00:07:07.664 --> 00:07:10.554
mas um pouco abaixo de 7,
por exemplo, 1,

00:07:10.554 --> 00:07:11.744
a gente vai ter a mensagem

00:07:11.744 --> 00:07:14.634
"Infelizmente, você não
foi aprovado no tp".

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

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

00:07:20.874 --> 00:07:24.054
que podem ou não serem formadas.

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

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

00:07:30.154 --> 00:07:32.214
ou se uma boleana estiver
informando algo,

00:07:32.214 --> 00:07:35.334
então eu posso assumir
que uma outra variável tem um valor.

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

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

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

00:07:45.374 --> 00:07:47.764
a gente também tem
diversas possibilidades.

00:07:47.764 --> 00:07:50.714
Cada um atende um cenário
e cabe a gente a decidir

00:07:50.714 --> 00:07:53.094
qual que é a melhor para o nosso
caso de uso específico.