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

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

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

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

0:00:17.971,0:00:20.550
de uma forma um pouco diferente.

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

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

0:00:25.179,0:00:28.017
e reaproveite o código,

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

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

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

0:00:34.632,0:00:36.826
desde que a gente especifique[br]eles corretamente

0:00:36.826,0:00:39.020
na assinatura do método.

0:00:39.020,0:00:39.986
E calma.

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

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

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

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

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

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

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

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

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

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

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

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

0:01:12.112,0:01:14.090
dentro de uma função.

0:01:14.090,0:01:15.920
E isso, na verdade, é a regra.

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

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

0:01:21.075,0:01:23.667
Mas existem alguns[br]cenários em que,

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

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

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

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

0:01:35.582,0:01:38.055
e exibir uma mensagem [br]com esse nome.

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

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

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

0:01:45.730,0:01:46.738
Simples.

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

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

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

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

0:01:59.410,0:02:00.492
A gente pode, sem problema nenhum,

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

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

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

0:02:08.920,0:02:10.212
Mas pensa aqui comigo.

0:02:10.212,0:02:11.504
A gente está trabalhando com Python,

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

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

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

0:02:20.465,0:02:21.557
que lida com qualquer [br]quantidade de notas

0:02:21.557,0:02:22.650
que a gente quiser informar?

0:02:22.650,0:02:23.860
Vamos lá, então.

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

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

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

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

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

0:02:35.222,0:02:37.040
ou melhor, executar[br]o nosso código,

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

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

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

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

0:02:47.760,0:02:49.890
um outro valor.

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

0:02:52.610,0:02:54.815
Repara que o Python dá um erro,

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

0:02:56.992,0:02:59.463
apenas um argumento, ou seja,[br]um parâmetro,

0:02:59.463,0:03:01.935
mas dois foram informados.

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

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

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

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

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

0:03:14.565,0:03:17.480
para ficar calcular média.

0:03:17.480,0:03:19.427
E pronto.

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

0:03:21.375,0:03:23.285
E é aqui que vem a chave.

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

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

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

0:03:31.860,0:03:33.825
Mas agora a gente vai usar

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

0:03:36.842,0:03:39.860
que esse parâmetro [br]é um parâmetro especial

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

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

0:03:47.030,0:03:48.256
E pronto.

0:03:48.256,0:03:50.375
A partir desse momento,

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

0:03:52.495,0:03:53.739
mas sim como uma tupla,

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

0:03:55.884,0:03:58.030
que não pode ser alterada.

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

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

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

0:04:06.570,0:04:08.340
para a gente ver a cara dela.

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

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

0:04:15.310,0:04:16.896
Porque lembra,

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

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

0:04:21.710,0:04:23.540
a gente não vai ter problema nenhum.

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

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

0:04:28.650,0:04:30.800
mesmo que em apenas uma variável.

0:04:30.800,0:04:32.237
E se a gente quiser,

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

0:04:34.383,0:04:36.530
como, por exemplo, aluna.

0:04:36.530,0:04:37.638
Se a gente executar,[br]a gente vê que,

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

0:04:41.170,0:04:42.230
aquele novo valor[br]que a gente formou

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

0:04:45.710,0:04:46.675
Então, agora sim,

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

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

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

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

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

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

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

0:05:04.104,0:05:06.355
para cada item[br]daquela minha tupla.

0:05:06.355,0:05:08.500
Lembra?

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

0:05:10.645,0:05:11.850
e a tupla é um deles.

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

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

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

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

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

0:05:25.397,0:05:27.365
que no caso é uma tupla.

0:05:27.365,0:05:29.812
E pronto.

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

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

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

0:05:39.530,0:05:40.310
Beleza?

0:05:40.310,0:05:41.070
Pronto.

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

0:05:44.385,0:05:46.290
Então, para terminar a lógica,

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

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

0:05:52.115,0:05:55.645
Ela vai ser basicamente[br]igual à minha soma,

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

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

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

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

0:06:09.345,0:06:11.830
e pronto.

0:06:11.830,0:06:14.660
Vou colocar aqui um return, média,

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

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

0:06:19.950,0:06:22.090
hum, repara que a gente teve um erro.

0:06:22.090,0:06:24.215
Isso aconteceu basicamente

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

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

0:06:29.570,0:06:30.410
Dá uma olhada.

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

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

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

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

0:06:42.660,0:06:45.405
Eu vou informar a nota 5 e a nota 5.

0:06:45.405,0:06:46.955
Eu vou limpar o terminal

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

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

0:06:52.680,0:06:54.830
mas a gente não tem nada na tela.

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

0:06:56.890,0:06:58.950
e ela retornou o valor.

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

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

0:07:05.400,0:07:08.015
e usar a função nativa print,

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

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

0:07:13.010,0:07:15.380
agora sim, a gente tem a média 5.

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

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

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

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

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

0:07:32.440,0:07:33.670
Cuidado para não confundir.

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

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

0:07:39.382,0:07:41.770
com outros tipos[br]de variáveis comuns,

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

0:07:44.220,0:07:46.670
e deixe os args para o final.

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

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

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

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

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

0:08:01.269,0:08:03.185
que vão vir de algum recurso externo,

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

0:08:07.070,0:08:08.850
mas quer lidar com todos eles.

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

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

0:08:13.203,0:08:15.730
se preocupar com a quantidade informada.