0:00:07.864,0:00:09.364
Parâmetros ajudam a gente

0:00:09.364,0:00:11.314
a modular o comportamento[br]de uma função,

0:00:11.314,0:00:13.984
e a gente já sabe como[br]definir parâmetros simples,

0:00:13.984,0:00:16.344
que são informados[br]de forma posicional,

0:00:16.344,0:00:18.434
e parâmetros[br]de quantidade dinâmica,

0:00:18.434,0:00:19.774
em que a gente consegue[br]lidar com eles

0:00:19.774,0:00:21.654
como se fosse uma coleção qualquer.

0:00:21.654,0:00:24.534
Chegou a hora da gente ver[br]como lidar com parâmetros

0:00:24.534,0:00:27.054
que podem ou não virem[br]para a nossa função.

0:00:27.054,0:00:30.234
O que a gente vai ver[br]agora são chamados Kwargs,

0:00:30.234,0:00:33.394
ou Keyword Arguments,[br]que são argumentos

0:00:33.394,0:00:36.024
que a gente passa[br]no formato de dicionário.

0:00:36.024,0:00:37.084
E para que eles servem?

0:00:37.084,0:00:39.773
Imagina que você tem que trabalhar[br]com a função

0:00:39.773,0:00:42.714
que você tem um valor específico [br]que tem que ser informado.

0:00:42.714,0:00:45.884
Nesse cenário, você informa para ele[br]um parâmetro simples,

0:00:45.884,0:00:48.444
que sempre vai estar lá,[br]e que se não for informado,

0:00:48.444,0:00:50.114
o Python dá um erro.

0:00:50.114,0:00:53.924
Por outro lado, se você tem[br]uma lista de quantidade dinâmica,

0:00:53.924,0:00:57.444
a gente vai ter que usar os Args,[br]para que a gente consiga manipular eles

0:00:57.444,0:01:00.954
de forma dinâmica, sem se preocupar[br]com a quantidade total.

0:01:00.954,0:01:03.564
No entanto, a gente pode querer[br]um parâmetro

0:01:03.564,0:01:05.654
que vai estar ou não presente.

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

0:01:08.224,0:01:10.854
Se ele estiver presente,[br]a gente faz alguma coisa com ele.

0:01:10.854,0:01:14.164
Caso não, a gente não faz[br]ou assume algum valor padrão.

0:01:14.164,0:01:17.764
E para isso, a estrutura de dados[br]mais adequada que a gente conhece

0:01:17.764,0:01:18.714
é o dicionário,

0:01:18.714,0:01:22.354
que é justamente o tipo entregue[br]quando a gente usa os Kwargs.

0:01:22.354,0:01:24.384
Então, agora, vamos[br]lá para o código e dar uma olhada

0:01:24.384,0:01:26.004
em como esse cara funciona.

0:01:26.004,0:01:26.974
Aqui no VS Code,

0:01:26.974,0:01:28.444
a gente já tem[br]um código de exemplo,

0:01:28.444,0:01:31.354
que é uma função simples[br]que exibe uma mensagem olá

0:01:31.354,0:01:32.744
e algum nome que foi entregue.

0:01:32.744,0:01:35.484
Se a gente exibir ela aqui,[br]executar ela, na verdade,

0:01:35.484,0:01:36.534
com o comando do Python,

0:01:36.534,0:01:38.754
a gente vai ver exatamente[br]isso na tela.

0:01:38.754,0:01:42.354
Mas, imagina que a gente queira[br]receber aqui a informação

0:01:42.354,0:01:44.764
de se esse aluno[br]fez ou não um trabalho prático.

0:01:44.764,0:01:46.994
Então, a gente precisa[br]de uma informação

0:01:46.994,0:01:48.844
que vai dizer para a gente,[br]na verdade,

0:01:48.844,0:01:51.064
a nota que ele tirou[br]nesse trabalho prático.

0:01:51.064,0:01:54.304
E se ele não tiver uma nota,[br]não significa que ele tirou zero.

0:01:54.304,0:01:55.974
Significa que ele não entregou.

0:01:55.974,0:01:56.654
Tá bom?

0:01:56.654,0:01:58.004
Então, vamos começar com isso.

0:01:58.004,0:02:01.244
A gente poderia definir[br]aqui duas variáveis.

0:02:01.244,0:02:03.734
Uma para informar se ele fez[br]ou não um trabalho prático.

0:02:03.734,0:02:05.634
E, para isso, a gente usaria[br]o tipo booleano.

0:02:05.634,0:02:08.284
E, depois, uma outra[br]para especificar a nota.

0:02:08.284,0:02:10.524
Mas, como a gente[br]consegue usar os Kwargs,

0:02:10.524,0:02:12.244
a gente vai fazer isso[br]de uma vez só,

0:02:12.244,0:02:13.924
informando apenas a nota.

0:02:13.924,0:02:14.784
Então, saca só.

0:02:14.784,0:02:17.354
Eu vou colocar aqui[br]a minha outra variável,

0:02:17.354,0:02:18.724
que vai ser o meu[br]outro parâmetro,

0:02:18.724,0:02:24.964
que eu vou chamar[br]de informações adicionais.

0:02:24.964,0:02:28.754
E, nesse caso, para que o Python[br]entenda que isso daqui é um Kwargs

0:02:28.754,0:02:30.814
e não uma variável simples,

0:02:30.814,0:02:33.014
eu vou ter que colocar[br]não um, mas, dessa vez,

0:02:33.014,0:02:35.254
dois asteriscos[br]no começo dela.

0:02:35.254,0:02:36.584
Então, pronto.

0:02:36.584,0:02:38.884
A partir de agora,[br]se eu executar a aplicação

0:02:38.884,0:02:42.214
sem mexer na invocação[br]ou no conteúdo daquela função,

0:02:42.214,0:02:45.084
o Python consegue executar isso[br]sem problema nenhum.

0:02:45.084,0:02:47.804
Porque ele já entendeu[br]que isso se trata de um Kwargs

0:02:47.804,0:02:50.514
e que as informações[br]que estão ali, elas são opcionais.

0:02:50.514,0:02:52.704
Ou seja, eu posso informar ou não.

0:02:52.704,0:02:55.024
Se a gente vier aqui[br]dentro do bloco de código,

0:02:55.024,0:02:56.794
vamos executar um print[br]com aquele valor,

0:02:56.794,0:02:58.434
só para a gente entender[br]o formato que as coisas

0:02:58.434,0:02:59.924
estão chegando aqui dentro.

0:02:59.924,0:03:04.704
Eu vou copiar o nome da variável [br]e, aqui, chamar a função nativa print,

0:03:04.704,0:03:06.994
passando ela para a gente[br]ver ali no terminal.

0:03:06.994,0:03:08.534
Eu vou executar mais uma vez.

0:03:08.534,0:03:11.064
E repara que a mensagem[br]está aqui e que, aqui embaixo,

0:03:11.064,0:03:12.974
dessa vez, eu tenho um dicionário,

0:03:12.974,0:03:16.779
que é aquela estrutura que a gente[br]usa baseada em chave e valor.

0:03:16.779,0:03:19.374
Então, eu vou começar aqui,[br]na invocação do método,

0:03:19.374,0:03:22.354
passando valores[br]para esse meu Kwargs.

0:03:22.354,0:03:26.694
E, para fazer isso, eu posso[br]passar eles no formato de chaves.

0:03:26.694,0:03:29.520
Ou seja, eu tenho que colocar[br]o nome e o valor que eu quero

0:03:29.520,0:03:30.414
para aquela chave.

0:03:30.414,0:03:35.213
No nosso caso, vai ser a nota[br]do trabalho prático, ou seja, nota tp.

0:03:35.213,0:03:38.314
Então, por isso, eu vou[br]colocar aqui nota tp,

0:03:38.314,0:03:41.014
o sinal de igual e o valor[br]que eu quero informar.

0:03:41.014,0:03:43.534
Que, nesse caso, [br]vai ser, por exemplo, 10.

0:03:43.534,0:03:46.524
Eu vou só salvar o meu programa[br]e executar de novo

0:03:46.524,0:03:48.464
para a gente ver o que mudou.

0:03:48.464,0:03:50.974
Aqui, a mensagem continua[br]a mesma coisa, só que,

0:03:50.974,0:03:53.424
dessa vez, repara que dentro[br]do meu dicionário,

0:03:53.424,0:03:56.984
eu tenho a chave[br]nota tp com valor 10.

0:03:56.984,0:03:57.884
E, a partir daqui,

0:03:57.884,0:03:59.974
a gente já consegue trabalhar[br]com essa informação.

0:03:59.974,0:04:02.204
E é exatamente isso que a gente[br]vai fazer aqui agora.

0:04:02.204,0:04:04.744
Eu vou abrir um espacinho[br]entre as duas mensagens

0:04:04.744,0:04:06.414
e uma coisa que a gente[br]tem que lembrar

0:04:06.414,0:04:10.254
é que os Kwargs são informações[br]realmente opcionais.

0:04:10.254,0:04:11.904
Então, a gente tem que lidar[br]com o cenário

0:04:11.904,0:04:14.154
delas estarem presentes ou não.

0:04:14.154,0:04:17.024
E a estrutura do dicionário[br]entrega formas

0:04:17.024,0:04:19.484
de a gente lidar com isso[br]sem problema algum.

0:04:19.484,0:04:20.624
Então, eu vou, basicamente,

0:04:20.624,0:04:23.124
antes de usar as informações[br]daquele dicionário,

0:04:23.124,0:04:25.384
ver se tem alguma informação[br]dentro da chave

0:04:25.384,0:04:26.894
que eu estou pretendendo usar.

0:04:26.894,0:04:29.214
Então, para isso, a nossa regra[br]vai ser a seguinte.

0:04:29.214,0:04:30.924
Se a gente não tiver[br]aquela chave,

0:04:30.924,0:04:33.584
significa que o aluno[br]não fez o trabalho prático.

0:04:33.584,0:04:34.804
E, por isso, eu vou,[br]basicamente,

0:04:34.804,0:04:37.744
exibir uma mensagem falando[br]que a gente não encontrou tp.

0:04:37.744,0:04:38.464
Vamos lá.

0:04:38.464,0:04:42.234
Aqui dentro, eu vou começar[br]com uma condicional para que eu veja

0:04:42.234,0:04:46.074
se a chave nota tp está[br]dentro daquela minha variável.

0:04:46.074,0:04:48.404
Então, eu vou colocar[br]aqui entre aspas,

0:04:48.404,0:04:53.434
"nota tp" in informacoes_adicionais.

0:04:53.434,0:04:56.854
Ou seja, se aquela nota estiver[br]dentro daquelas informações,

0:04:56.854,0:04:59.214
então esse bloco de código[br]vai ser executado.

0:04:59.214,0:05:01.484
Mas como que eu quero[br]exatamente o contrário,

0:05:01.484,0:05:04.154
eu vou colocar uma negação[br]aqui antes do in.

0:05:04.154,0:05:05.834
Então, fica da seguinte forma.

0:05:05.834,0:05:09.394
Se a chave nota tp[br]não estiver dentro do dicionário

0:05:09.394,0:05:10.894
informações adicionais,

0:05:10.894,0:05:18.424
então eu quero exibir uma mensagem[br]falando que o tp não foi encontrado.

0:05:18.424,0:05:21.794
E como, a partir daqui,[br]eu não quero executar mais nada,

0:05:21.794,0:05:25.184
eu vou apenas escrever um return[br]para que o Python entenda

0:05:25.184,0:05:28.074
que eu não tenho que executar[br]mais nada daqui para frente

0:05:28.074,0:05:29.864
e saia dessa função.

0:05:29.864,0:05:32.784
Vamos rodar aqui de novo[br]o nosso terminal.

0:05:32.784,0:05:36.024
Ou melhor, limpar o terminal[br]e executar novamente a aplicação

0:05:36.024,0:05:39.384
para a gente ver como que as coisas[br]se comportam do jeito que está.

0:05:39.384,0:05:42.684
Desse jeito aqui, a aplicação[br]não entrou na condicional

0:05:42.684,0:05:43.609
e seguiu adiante

0:05:43.609,0:05:46.631
exibindo aquele nosso dicionário [br]de informações adicionais.

0:05:46.631,0:05:50.154
Mas se a partir de agora[br]eu remover essa informação,

0:05:50.154,0:05:53.034
ele entra na condicional[br]e exibe a mensagem para a gente.

0:05:53.034,0:05:55.454
Então eu vou voltar com ela daqui[br]para que a gente coloque

0:05:55.454,0:05:59.094
mais coisa aqui no fluxo[br]do nosso programa.

0:05:59.094,0:06:00.204
E a partir desse momento,

0:06:00.204,0:06:01.414
a gente está trabalhando[br]com a possibilidade

0:06:01.414,0:06:03.813
de que a nota está sendo entregue.

0:06:03.813,0:06:07.344
Então eu vou colocar um if para ver[br]se essa nota é maior do que 7.

0:06:07.344,0:06:08.804
Se for, então o aluno[br]está aprovado.

0:06:08.804,0:06:11.514
Se não for, então o aluno[br]está reaprovado.

0:06:11.514,0:06:13.775
Então eu vou começar[br]com mais uma condicional

0:06:13.775,0:06:16.251
e eu vou acessar[br]o informações adicionais

0:06:16.251,0:06:19.764
e usar o método get[br]para pegar aquela chave.

0:06:19.764,0:06:21.411
Qual é a chave?

0:06:21.411,0:06:22.814
a nota tp.

0:06:22.814,0:06:26.374
Eu copio aqui e vejo se ela [br]é maior do que 7.

0:06:26.374,0:06:30.104
Se ela for maior do que 7,[br]eu vou copiar aqui essa mensagem

0:06:30.104,0:06:37.864
e eu vou editar para que ela seja:[br]"Parabéns, você foi aprovado no tp".

0:06:37.864,0:06:40.874
E eu também vou definir[br]um caso padrão, que é o Else,

0:06:40.874,0:06:43.314
para quando essa condicional[br]não for atendida.

0:06:43.314,0:06:46.614
E se esse for o caso,[br]eu vou exibir a mensagem.

0:06:46.614,0:06:51.392
"Infelizmente, você não[br]foi aprovado no tp".

0:06:51.392,0:06:52.704
E pronto.

0:06:52.704,0:06:56.124
Deixa eu só tirar essa mensagem[br]aqui de baixo, limpar o terminal,

0:06:56.124,0:06:58.534
e se a gente executa[br]a nossa aplicação novamente,

0:06:58.534,0:06:59.634
a gente tem a mensagem

0:06:59.634,0:07:04.034
"Olá, Aluno", que a gente não mexeu,[br]e "Parabéns, você foi aprovado no TP".

0:07:04.034,0:07:06.124
Se a gente abaixa[br]um pouco essa nota aqui,

0:07:06.124,0:07:07.574
para algo próximo de 10,

0:07:07.574,0:07:10.554
mais um pouco abaixo de 7,[br]por exemplo, 1,

0:07:10.554,0:07:11.744
a gente vai ter a mensagem

0:07:11.744,0:07:14.294
"Infelizmente, você não[br]foi aprovado no TP".

0:07:14.294,0:07:17.734
E é dessa forma que a gente[br]consegue preparar as nossas funções

0:07:17.734,0:07:20.874
para que elas consigam lidar[br]com informações opcionais, ou seja,

0:07:20.874,0:07:23.794
que podem ou não serem formadas.

0:07:23.794,0:07:27.074
Claro, a gente poderia[br]também lidar com informações

0:07:27.074,0:07:30.154
do tipo se a variável[br]estiver com um valor vazio,

0:07:30.154,0:07:32.214
ou se uma boleana estiver[br]informando algo,

0:07:32.214,0:07:35.334
então eu posso assumir[br]que uma outra variável tem um valor.

0:07:35.334,0:07:38.854
Mas está começando a ficar bem claro[br]que isso ficaria muito complicado

0:07:38.854,0:07:42.364
de dar manutenção e até mesmo[br]de entender o que está acontecendo.

0:07:42.364,0:07:45.684
E da mesma forma com que a gente[br]tem diversas estruturas de dados,

0:07:45.684,0:07:47.764
a gente também tem[br]diversas possibilidades.

0:07:47.764,0:07:50.714
Cada um atende um cenário[br]e cabe a gente a decidir

0:07:50.714,0:07:53.334
qual que é a melhor para o nosso[br]caso de uso específico.