0:00:18.750,0:00:19.498
Parâmetros ajudam a gente

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

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

0:00:21.568,0:00:22.839
que são informados[br]de forma posicional,

0:00:22.839,0:00:24.178
e parâmetros [br]de quantidade dinâmica,

0:00:24.178,0:00:25.517
em que a gente consegue [br]lidar com eles

0:00:25.517,0:00:26.139
como se fosse uma coleção qualquer.

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

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

0:00:29.380,0:00:31.317
O que a gente vai ver[br]agora são chamados KWARGs,

0:00:31.317,0:00:33.267
ou Keyword Arguments, [br]que são argumentos

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

0:00:35.198,0:00:37.130
E para que eles servem?

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

0:00:44.250,0:00:45.480
um valor específico que tem[br]que ser informado.

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

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

0:00:49.962,0:00:52.660
o Python dá um erro.

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

0:00:54.592,0:00:56.534
a gente vai ter que usar os args,[br]para que a gente consiga manipular eles

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

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

0:01:04.735,0:01:06.572
que vai estar ou não presente.

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

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

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

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

0:01:18.102,0:01:19.135
é o dicionário,

0:01:19.135,0:01:22.455
que é justamente o tipo entregue [br]quando a gente usa os KWARGs.

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

0:01:24.362,0:01:26.270
em como esse cara funciona.

0:01:26.270,0:01:27.951
Aqui no VS Code,

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

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

0:01:30.805,0:01:32.820
e algum nome que foi entregue.

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

0:01:35.357,0:01:37.508
com o comando do Python,

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

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

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

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

0:01:46.980,0:01:49.075
que vai dizer para a gente,[br]na verdade,

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

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

0:01:53.660,0:01:56.150
Significa que ele não entregou.

0:01:56.150,0:01:57.115
Tá bom?

0:01:57.115,0:01:58.080
Então, vamos começar com isso.

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

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

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

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

0:02:08.415,0:02:09.792
Mas, como a gente [br]consegue usar os KWARGs,

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

0:02:11.911,0:02:13.520
informando apenas a nota.

0:02:13.520,0:02:15.130
Então, saca só.

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

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

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

0:02:25.060,0:02:28.015
E, nesse caso, para que o Python[br]entenda que isso daqui é um KWARGs

0:02:28.015,0:02:30.970
e não uma variável simples,

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

0:02:33.155,0:02:35.340
dois asteriscos[br]no começo dela.

0:02:35.340,0:02:36.393
Então, pronto.

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

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

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

0:02:45.250,0:02:47.841
Porque ele já entendeu[br]que isso se trata de um KWARGs

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

0:02:50.650,0:02:52.780
Ou seja, eu posso informar ou não.

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

0:02:54.582,0:02:56.385
vamos executar um print [br]com aquele valor,

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

0:02:58.232,0:03:00.080
estão chegando aqui dentro.

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

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

0:03:07.150,0:03:08.640
Eu vou executar mais uma vez.

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

0:03:10.875,0:03:13.110
dessa vez, eu tenho um dicionário,

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

0:03:16.900,0:03:19.328
Então, eu vou começar[br]aqui, na invocação

0:03:19.328,0:03:22.171
do método, passando valores[br]para esse meu QArgs.

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

0:03:26.800,0:03:28.389
Ou seja, eu tenho[br]que colocar o nome

0:03:28.389,0:03:30.520
e o valor que eu quero[br]para aquela chave.

0:03:30.520,0:03:32.385
No nosso caso,[br]vai ser a nota

0:03:32.385,0:03:35.410
do trabalho prático,[br]ou seja, nota tp.

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

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

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

0:03:43.690,0:03:45.883
Eu vou só salvar o meu[br]programa e executar

0:03:45.883,0:03:48.580
de novo para a gente[br]ver o que mudou.

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

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

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

0:03:57.080,0:03:58.618
E, a partir daqui,[br]a gente já consegue

0:03:58.618,0:04:00.250
trabalhar[br]com essa informação.

0:04:00.250,0:04:02.395
E é exatamente isso que a gente[br]vai fazer aqui agora.

0:04:02.395,0:04:04.101
Eu vou abrir um espacinho[br]entre as duas

0:04:04.101,0:04:06.520
mensagens e uma coisa[br]que a gente tem que lembrar

0:04:06.520,0:04:10.350
é que os QArgs são informações[br]realmente opcionais.

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

0:04:12.407,0:04:14.240
delas estarem[br]presentes ou não.

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

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

0:04:19.450,0:04:21.340
Então, eu vou,[br]basicamente, antes de usar

0:04:21.340,0:04:23.210
as informações[br]daquele dicionário,

0:04:23.210,0:04:24.861
ver se tem alguma[br]informação dentro

0:04:24.861,0:04:26.980
da chave que eu estou[br]pretendendo usar.

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

0:04:29.360,0:04:31.498
Se a gente não tiver[br]aquela chave, significa

0:04:31.498,0:04:33.680
que o aluno não Fez[br]o trabalho prático.

0:04:33.680,0:04:35.451
E, por isso, eu vou,[br]basicamente, exibir

0:04:35.451,0:04:37.810
uma mensagem falando[br]que a gente não encontrou tp.

0:04:37.810,0:04:38.670
Vamos lá.

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

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

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

0:04:49.914,0:04:53.540
nota tp em informações[br]adicionais.

0:04:53.540,0:04:56.044
Ou seja, se aquela nota[br]estiver dentro daquelas

0:04:56.044,0:04:59.340
informações, então esse bloco[br]de código vai ser executado.

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

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

0:05:04.260,0:05:06.000
Então, fica da seguinte forma.

0:05:06.000,0:05:08.355
Se a chave nota tp[br]não estiver dentro

0:05:08.355,0:05:10.985
do dicionário[br]informações adicionais,

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

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

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

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

0:05:28.170,0:05:29.970
e saia dessa função.

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

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

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

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

0:05:42.820,0:05:44.292
e seguiu adiante[br]exibindo aquele

0:05:44.292,0:05:46.660
nosso dicionário[br]de informações adicionais.

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

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

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

0:05:55.975,0:05:59.190
coloque mais coisa aqui[br]no fluxo do nosso programa.

0:05:59.190,0:06:01.347
E a partir desse momento,[br]a gente está trabalhando

0:06:01.347,0:06:03.870
com a possibilidade de que a nota[br]está sendo entregue.

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

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

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

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

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

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

0:06:19.750,0:06:21.600
Qual que é a chave?

0:06:21.600,0:06:22.950
a nota tp.

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

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

0:06:30.210,0:06:31.670
e eu vou editar para que ela seja.

0:06:33.740,0:06:37.900
parabéns, você foi aprovado no tp.

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

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

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

0:06:48.500,0:06:51.430
Infelizmente, você não[br]foi aprovado no tp.

0:06:51.430,0:06:52.730
E pronto.

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

0:06:56.240,0:06:58.293
e se a gente executa[br]a nossa aplicação

0:06:58.293,0:07:00.094
novamente, a gente[br]tem a mensagem

0:07:00.094,0:07:04.240
Olá aluno, que a gente não mexeu,[br]e parabéns, você foi aprovado no tp.

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

0:07:06.634,0:07:09.151
para algo próximo de 10,[br]mas um pouco abaixo

0:07:09.151,0:07:11.856
de 7, por exemplo, 1,[br]a gente vai ter a mensagem

0:07:11.856,0:07:14.720
Infelizmente, você não[br]foi aprovado no tp.

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

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

0:07:21.090,0:07:24.190
que podem ou não serem formadas.

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

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

0:07:29.630,0:07:32.218
ou se uma boleana estiver[br]informando algo, então

0:07:32.218,0:07:35.460
eu posso assumir que uma outra[br]variável tem um valor.

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

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

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

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

0:07:47.890,0:07:50.727
Cada um atende um cenário[br]e cabe a gente a decidir qual

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