0:00:05.524,0:00:10.354
A gente deu nosso primeiro passo[br]no reaproveitamento de código

0:00:10.354,0:00:13.564
com as funções e entendeu[br]também como usar os parâmetros.

0:00:13.564,0:00:15.044
Mas agora está na hora[br]da gente dar uma olhada

0:00:15.044,0:00:18.384
em um outro tipo de parâmetro[br]que permite que a gente informe dados

0:00:18.384,0:00:19.934
de uma forma um pouco diferente.

0:00:19.934,0:00:23.194
Está na hora da gente[br]olhar um pouco os args.

0:00:23.194,0:00:26.054
A gente já sabe que as funções[br]servem para que a gente isole

0:00:26.054,0:00:27.904
e reaproveite o código,

0:00:27.904,0:00:30.744
e que a gente também pode[br]informar parâmetros para elas.

0:00:30.744,0:00:32.824
Não há necessariamente[br]uma quantidade limite

0:00:32.824,0:00:34.774
de parâmetros[br]que a gente pode informar,

0:00:34.774,0:00:37.274
desde que a gente especifique[br]eles corretamente

0:00:37.274,0:00:38.884
na assinatura do método.

0:00:38.884,0:00:39.674
E calma.

0:00:39.674,0:00:41.424
Quando a gente fala assinatura[br]do método,

0:00:41.424,0:00:44.234
a gente está basicamente[br]falando daquela primeira linha,

0:00:44.234,0:00:47.204
aonde a gente define o nome[br]e os parâmetros da função,

0:00:47.204,0:00:51.294
que, por acaso, a gente pode[br]especificar quantos a gente quiser.

0:00:51.294,0:00:53.764
Basta que a gente coloque[br]os seus nomes adequados.

0:00:53.764,0:00:57.464
Por exemplo, nome, idade[br]ou qualquer outra informação

0:00:57.464,0:01:00.074
que a gente queira usar dentro[br]daquela função.

0:01:00.074,0:01:03.024
E, lembra, o nome que a gente[br]colocar na assinatura

0:01:03.024,0:01:06.294
é como a gente vai referenciá-las[br]dentro do bloco da função.

0:01:06.294,0:01:08.264
Na maioria dos casos,[br]a gente vai ter bem claro

0:01:08.264,0:01:10.314
quais são as informações[br]que a gente precisa

0:01:10.314,0:01:12.634
para executar um determinado[br]bloco de código

0:01:12.634,0:01:13.974
dentro de uma função.

0:01:13.974,0:01:15.824
E isso, na verdade, é a regra.

0:01:15.824,0:01:18.124
A gente precisa saber[br]quais são as informações

0:01:18.124,0:01:20.954
para que a gente saiba[br]como lidar com elas dentro do código.

0:01:20.954,0:01:23.134
Mas existem alguns[br]cenários em que,

0:01:23.134,0:01:25.744
embora a gente saiba quais[br]informações a gente precisa,

0:01:25.744,0:01:29.484
a gente não sabe exatamente[br]quantas informações vão vir.

0:01:29.484,0:01:33.004
E calma, eu sei que está um pouco[br]confuso, mas você já já vai entender.

0:01:33.004,0:01:36.064
Imagina que você tem uma função[br]que tem que receber um nome

0:01:36.064,0:01:37.884
e exibir uma mensagem[br]com esse nome.

0:01:37.884,0:01:40.294
Está bem claro aqui como[br]é que as coisas vão funcionar.

0:01:40.294,0:01:42.894
Dentro dos parâmetros, a gente vai[br]ter uma variável que representa o nome

0:01:42.894,0:01:45.434
e a gente vai usar[br]ela dentro da nossa função.

0:01:45.434,0:01:46.354
Simples.

0:01:46.354,0:01:50.284
Por outro lado, imagina que a gente[br]vai calcular alguma média.

0:01:50.284,0:01:52.434
A gente sabe como é feito[br]o cálculo de média.

0:01:52.434,0:01:55.494
A gente soma, por exemplo,[br]todas as notas de um aluno

0:01:55.494,0:01:59.354
e divide essa somatória[br]pela quantidade de notas totais.

0:01:59.354,0:02:01.054
A gente pode, sem problema nenhum,

0:02:01.054,0:02:03.674
implementar uma função[br]que recebe dois valores.

0:02:03.674,0:02:06.034
A gente vai, então, pegar[br]esses valores, somar,

0:02:06.034,0:02:08.784
e o que der de resultado,[br]a gente divide por dois.

0:02:08.784,0:02:09.644
Mas pensa aqui comigo.

0:02:09.644,0:02:11.414
A gente está trabalhando com Python,

0:02:11.414,0:02:14.184
e diversas possibilidades[br]estão na palma da nossa mão.

0:02:14.184,0:02:16.534
Então, por que, ao invés de a gente[br]implementar uma função

0:02:16.534,0:02:19.264
que lida com duas notas,[br]a gente implementa uma função

0:02:19.264,0:02:21.244
que lida com qualquer[br]quantidade de notas

0:02:21.244,0:02:22.704
que a gente quiser informar?

0:02:22.704,0:02:23.784
Vamos lá, então.

0:02:23.784,0:02:26.014
Aqui no VS Code, a gente[br]já tem um código inicial,

0:02:26.014,0:02:27.964
que é aquele nosso primeiro[br]exemplo que a gente comentou.

0:02:27.964,0:02:31.054
A gente tem uma função simples,[br]que recebe um parâmetro,

0:02:31.054,0:02:33.374
e ele é usado aqui para montar[br]alguma mensagem.

0:02:33.374,0:02:35.274
Se a gente exibir[br]aqui o nosso código,

0:02:35.274,0:02:36.614
ou melhor, executar[br]o nosso código,

0:02:36.614,0:02:39.914
a gente consegue ver que a mensagem[br]é exibida com sucesso,

0:02:39.914,0:02:43.674
e na invocação da função,[br]a gente passa apenas um parâmetro,

0:02:43.674,0:02:45.514
que no nosso caso[br]é o valor mundo.

0:02:45.514,0:02:48.654
Olha o que acontece se a gente[br]tentar passar aqui, por exemplo,

0:02:48.654,0:02:49.754
um outro valor.

0:02:49.754,0:02:52.464
Por exemplo, aluno,[br]que é uma outra string.

0:02:52.464,0:02:54.444
Repara que o Python dá um erro,

0:02:54.444,0:02:56.944
porque a gente especificou[br]que essa função recebe

0:02:56.944,0:02:59.974
apenas um argumento, ou seja,[br]um parâmetro,

0:02:59.974,0:03:01.824
mas dois foram informados.

0:03:01.824,0:03:04.344
E é exatamente o que a gente[br]vai querer fazer já já.

0:03:04.344,0:03:06.984
Eu vou começar, então,[br]editando o nome dessa função

0:03:06.984,0:03:09.224
para que faça mais sentido[br]com o que a gente quer fazer.

0:03:09.224,0:03:11.554
Aqui no nosso caso é fazer[br]o cálculo de uma média.

0:03:11.554,0:03:13.924
Então eu vou vir aqui[br]e vou editar o nome dela

0:03:13.924,0:03:17.394
para ficar calcular média.

0:03:17.394,0:03:18.154
E pronto.

0:03:18.154,0:03:21.264
Ao invés de um nome,[br]eu vou receber as notas aqui.

0:03:21.264,0:03:23.144
E é aqui que vem a chave.

0:03:23.144,0:03:25.764
Quando eu especifico os meus[br]parâmetros dessa forma,

0:03:25.764,0:03:29.234
eu estou informando para o Python[br]parâmetros posicionais

0:03:29.234,0:03:31.734
com uma quantidade[br]específica de itens.

0:03:31.734,0:03:32.994
Mas agora a gente vai usar

0:03:32.994,0:03:37.394
uma técnica chamada args do Python,[br]que permite que a gente informe para ele

0:03:37.394,0:03:39.754
que esse parâmetro[br]é um parâmetro especial

0:03:39.754,0:03:42.884
e que vai receber uma quantidade[br]não exata de itens.

0:03:42.884,0:03:46.864
E para isso, basta a gente colocar[br]o asterisco aqui no começo do nome.

0:03:46.864,0:03:47.494
E pronto.

0:03:47.494,0:03:48.344
A partir desse momento,

0:03:48.344,0:03:52.364
o Python vai tratar essa variável não[br]como uma variável normal,

0:03:52.364,0:03:54.014
mas sim como uma tupla,

0:03:54.014,0:03:56.094
que é basicamente[br]uma coleção de itens

0:03:56.094,0:03:57.934
que não pode ser alterada.

0:03:57.934,0:04:00.104
Então, antes da gente[br]implementar a nossa lógica,

0:04:00.104,0:04:04.684
vamos só colocar um print aqui,[br]exibindo o valor dessa variável

0:04:04.684,0:04:06.394
que a gente está recebendo[br]nos parâmetros,

0:04:06.394,0:04:08.244
para a gente ver a cara dela.

0:04:08.244,0:04:11.514
Então, aqui na execução do método,[br]eu vou atualizar o nome também

0:04:11.514,0:04:15.144
e eu vou deixar aqueles[br]nossos dois valores, mundo e aluno.

0:04:15.144,0:04:15.874
Porque lembra,

0:04:15.874,0:04:18.764
o Python é uma linguagem[br]de tipo dinâmico, então,

0:04:18.764,0:04:21.334
enquanto a gente não usar[br]os valores como se fossem números,

0:04:21.334,0:04:22.954
a gente não vai ter problema nenhum.

0:04:22.954,0:04:25.474
Se eu executar novamente[br]aqui o nosso código,

0:04:25.474,0:04:28.524
a gente repara que os dois[br]valores estão aqui,

0:04:28.524,0:04:30.654
mesmo que em apenas uma variável.

0:04:30.654,0:04:31.774
E se a gente quiser,

0:04:31.774,0:04:34.534
a gente pode vir aqui[br]e adicionar qualquer outra coisa,

0:04:34.534,0:04:36.344
como, por exemplo, aluna.

0:04:36.344,0:04:38.024
Se a gente executar,[br]a gente vê que,

0:04:38.024,0:04:41.034
mesmo sem alterar[br]a definição da nossa função,

0:04:41.034,0:04:42.624
aquele novo valor[br]que a gente formou

0:04:42.624,0:04:45.614
está lá dentro também,[br]dentro da nossa tupla.

0:04:45.614,0:04:46.494
Então, agora sim,

0:04:46.494,0:04:49.394
é hora da gente implementar[br]a nossa lógica do cálculo da média.

0:04:49.394,0:04:51.794
Então, para isso,[br]a gente vai vir aqui dentro

0:04:51.794,0:04:54.854
e vai começar com uma variável[br]que vai ser, por exemplo,

0:04:54.854,0:04:56.784
a soma, que vai[br]começar com zero.

0:04:56.784,0:04:59.394
Eu vou implementar isso aqui[br]de uma forma bem simples,

0:04:59.394,0:05:01.694
para que a gente entenda[br]como está sendo feito.

0:05:01.694,0:05:04.294
Então, eu vou começar[br]executando um loop

0:05:04.294,0:05:06.234
para cada item[br]daquela minha tupla.

0:05:06.234,0:05:06.774
Lembra?

0:05:06.774,0:05:10.514
O for permite que a gente[br]itere sobre vários tipos de dados,

0:05:10.514,0:05:11.674
e a tupla é um deles.

0:05:11.674,0:05:14.854
Se a gente fizer isso com a tupla,[br]ele vai passar por cada um dos itens,

0:05:14.854,0:05:17.714
e a gente vai ter a oportunidade[br]de fazer alguma coisa com esse número.

0:05:17.714,0:05:20.354
No nosso caso, eu vou passar[br]dentro das notas.

0:05:20.354,0:05:22.894
Para cada nota, eu vou chamar[br]ela de nota, aqui dentro,

0:05:22.894,0:05:26.074
e eu vou especificar[br]a minha lista, ou a minha coleção,

0:05:26.074,0:05:27.254
que no caso é uma tupla.

0:05:27.254,0:05:28.034
E pronto.

0:05:28.034,0:05:32.124
Aqui dentro, eu vou basicamente[br]usar o operador de soma,

0:05:32.124,0:05:35.624
para fazer com que o soma[br]receba o valor do próprio soma,

0:05:35.624,0:05:39.444
mais o valor da minha nota atual,[br]que está dentro do meu loop.

0:05:39.444,0:05:40.354
Beleza?

0:05:40.354,0:05:40.964
Pronto.

0:05:40.964,0:05:44.284
Nesse ponto aqui, a gente já tem[br]a somatória das nossas notas.

0:05:44.284,0:05:45.324
Então, para terminar a lógica,

0:05:45.324,0:05:48.094
basta a gente fazer a divisão[br]pela quantidade de notas.

0:05:48.094,0:05:52.014
Então, eu vou declarar uma outra[br]variável aqui, que vai ser a média.

0:05:52.014,0:05:55.544
Ela vai ser basicamente[br]igual à minha soma,

0:05:55.544,0:05:59.604
dividida pela quantidade de itens[br]que foram informadas naquela tupla.

0:05:59.604,0:06:02.594
E para fazer isso, a gente[br]pode usar a função nativa len,

0:06:02.594,0:06:06.734
que recebe alguma coleção e retorna[br]para a gente a quantidade de itens.

0:06:06.734,0:06:10.734
Então, basta a gente informar[br]aqui para ele a nossa variável notas,

0:06:10.734,0:06:11.714
e pronto.

0:06:11.714,0:06:14.514
Vou colocar aqui um return, média,

0:06:14.514,0:06:17.714
para fazer com que a nossa função[br]retorne o valor daquele cálculo.

0:06:17.714,0:06:19.804
E se a gente executar[br]o nosso programa de novo,

0:06:19.804,0:06:21.974
hum, repara que a gente teve um erro.

0:06:21.974,0:06:23.274
Isso aconteceu basicamente

0:06:23.274,0:06:26.204
porque a gente mudou a implementação[br]da nossa função,

0:06:26.204,0:06:29.124
mas esqueceu de mudar os valores[br]que foram informados no parâmetro.

0:06:29.124,0:06:30.274
Dá uma olhada.

0:06:30.274,0:06:34.404
Aqui dentro, a gente está informando[br]mundo, aluno e aluna, que são texto.

0:06:34.404,0:06:37.384
E agora sim, a gente está lidando[br]com valores numéricos.

0:06:37.384,0:06:40.094
Então, basta que a gente[br]edite aqui esses valores.

0:06:40.094,0:06:42.504
Então, vamos começar[br]com uma conta simples aqui.

0:06:42.504,0:06:45.244
Eu vou informar a nota 5 e a nota 5.

0:06:45.244,0:06:46.374
Eu vou limpar o terminal

0:06:46.374,0:06:48.374
para que fique um pouco[br]mais simples as coisas.

0:06:48.374,0:06:52.554
E se a gente rodar novamente,[br]novamente, o nosso aplicativo rodou,

0:06:52.554,0:06:54.744
mas a gente não tem nada na tela.

0:06:54.744,0:06:57.434
E isso aconteceu porque a gente[br]executou a função

0:06:57.434,0:06:58.804
e ela retornou o valor.

0:06:58.804,0:07:00.834
Mas a gente não exibiu[br]isso de lugar em algum.

0:07:00.834,0:07:05.294
Então, eu vou basicamente envolver[br]essa função dentro dos parênteses

0:07:05.294,0:07:08.324
e usar a função nativa print,

0:07:08.324,0:07:09.984
para que agora sim[br]esse valor seja exibido.

0:07:09.984,0:07:12.854
E se a gente roda de novo[br]com os mesmos valores,

0:07:12.854,0:07:15.254
agora sim, a gente tem a média 5.

0:07:15.254,0:07:18.254
E se eu acrescentar algum valor[br]aqui, como, por exemplo, 10,

0:07:18.254,0:07:22.124
a gente tem como[br]resultado a média 6.

0:07:22.124,0:07:24.804
6, que é o resultado[br]da somatória de 5,

0:07:24.804,0:07:28.674
5 e 10, dividido pela[br]quantidade total, que é 3.

0:07:28.674,0:07:32.294
E é dessa forma que a gente consegue[br]lidar com informações dinâmicas.

0:07:32.294,0:07:33.194
Cuidado para não confundir.

0:07:33.194,0:07:37.004
A gente ainda precisa especificar[br]quais são as variáveis.

0:07:37.004,0:07:39.594
E a gente pode usar[br]os args em conjunto

0:07:39.594,0:07:41.684
com outros tipos[br]de variáveis comuns,

0:07:41.684,0:07:44.954
desde que a gente especifique[br]as variáveis comuns no começo

0:07:44.954,0:07:46.674
e deixe os args para o final.

0:07:46.674,0:07:49.344
A gente usou os args aqui[br]para fazer o cálculo de uma média,

0:07:49.344,0:07:51.674
que é um cenário[br]em que realmente, talvez,

0:07:51.674,0:07:55.864
a gente tenha uma quantidade dinâmica[br]de itens e a gente tenha que lidar com isso.

0:07:55.864,0:07:59.404
E é exatamente nesse tipo de cenário[br]em que você vai querer usar os args.

0:07:59.404,0:08:02.044
Normalmente, a gente costuma[br]usar eles com listas,

0:08:02.044,0:08:03.924
que vão vir de algum recurso externo,

0:08:03.924,0:08:06.944
onde a gente não controla[br]a quantidade de itens que vai ter,

0:08:06.944,0:08:08.734
mas quer lidar com todos eles.

0:08:08.734,0:08:10.594
E é dessa forma que a gente[br]consegue lidar

0:08:10.594,0:08:13.804
com essa lista dinâmica de itens,[br]sem ter que necessariamente

0:08:13.804,0:08:15.584
se preocupar com a quantidade informada.