0:00:18.750,0:00:20.247
Parâmetros ajudam a gente[br]a modular o comportamento

0:00:20.247,0:00:21.352
de uma função,[br]e a gente já sabe como

0:00:21.352,0:00:22.711
definir parâmetros[br]simples, que são informados

0:00:22.711,0:00:24.111
de forma posicional,[br]e parâmetros de quantidade

0:00:24.111,0:00:25.517
dinâmica, em que a gente[br]consegue lidar com eles

0:00:25.517,0:00:26.762
como se fosse uma coleção qualquer.[br]Chegou

0:00:26.762,0:00:28.088
a hora da gente ver como[br]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.411
O que a gente vai ver[br]agora são chamados

0:00:31.411,0:00:33.255
QArgs, ou Keyword[br]Arguments, que são

0:00:33.255,0:00:35.217
argumentos que a gente[br]passa no formato

0:00:35.217,0:00:37.130
de dicionário.[br]E para que eles servem?

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

0:00:44.224,0:00:46.710
um valor específico que tem[br]que ser informado. Nesse cenário,

0:00:46.710,0:00:49.050
você informa para ele um parâmetro[br]simples, que sempre vai

0:00:49.050,0:00:52.660
estar lá, e que se não for[br]informado, o Python dá um erro.

0:00:52.660,0:00:54.747
Por outro lado, se você[br]tem uma lista de quantidade

0:00:54.747,0:00:56.525
dinâmica, a gente vai[br]ter que usar os args,

0:00:56.525,0:00:58.477
para que a gente consiga[br]manipular eles de forma

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

0:01:01.060,0:01:04.595
No entanto, a gente pode querer[br]um parâmetro que vai estar

0:01:04.595,0:01:08.410
ou não presente. Ou seja,[br]ele é uma informação opcional.

0:01:08.410,0:01:11.366
Se ele estiver presente, a gente[br]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:20.168
é o dicionário,[br]que é justamente o tipo

0:01:20.168,0:01:22.455
entregue quando[br]a gente usa os QArgs.

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

0:01:24.194,0:01:26.270
uma olhada em como[br]esse cara funciona.

0:01:26.270,0:01:27.780
Aqui no VS Code,[br]a gente já tem

0:01:27.780,0:01:29.632
um código de exemplo,[br]que é uma função

0:01:29.632,0:01:32.820
simples que exibe uma mensagem[br]olá 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:39.660
com o comando do Python, a gente[br]vai ver exatamente 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 Fez[br]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:48.248
que vai dizer[br]para a gente,

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

0:01:51.170,0:01:53.320
E se ele não tiver[br]uma nota, não significa

0:01:53.320,0:01:56.150
que ele tirou zero.[br]Significa que ele não entregou.

0:01:56.150,0:01:58.080
Tá bom?[br]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[br]usaria 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:11.169
Mas, como a gente consegue[br]usar os QArgs, a gente vai

0:02:11.169,0:02:14.030
fazer isso de uma vez só,[br]informando apenas a nota.

0:02:14.030,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.055
E, nesse caso, para que o Python[br]entenda que isso

0:02:28.055,0:02:30.970
daqui é um QArgs e não[br]uma variável simples,

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

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

0:02:35.340,0:02:37.446
Então, pronto.[br]A partir de agora, se

0:02:37.446,0:02:40.134
eu executar a aplicação[br]sem mexer na invocação

0:02:40.134,0:02:42.389
ou no conteúdo daquela[br]função, o Python

0:02:42.389,0:02:45.250
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 QArgs

0:02:47.841,0:02:50.650
e que as informações que estão[br]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.382
Se a gente vier[br]aqui dentro do bloco

0:02:54.382,0:02:56.385
de código, vamos executar[br]um print com aquele

0:02:56.385,0:02:58.188
valor, só para a gente[br]entender o formato

0:02:58.188,0:03:00.080
que as coisas estão[br]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.785
E repara que a mensagem[br]está aqui e que, aqui

0:03:10.785,0:03:13.110
embaixo, dessa vez,[br]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.