WEBVTT

00:00:07.965 --> 00:00:10.824
A gente deu nosso primeiro passo
no reaproveitamento de código

00:00:10.824 --> 00:00:13.690
com as funções e entendeu
também como usar os parâmetros.

00:00:13.690 --> 00:00:15.392
Mas agora está na hora 
da gente dar uma olhada

00:00:15.392 --> 00:00:17.971
em um outro tipo de parâmetro
que permite que a gente informe dados

00:00:17.971 --> 00:00:20.550
de uma forma um pouco diferente.

00:00:20.550 --> 00:00:23.270
Está na hora da gente
olhar um pouco os args.

00:00:23.270 --> 00:00:25.179
A gente já sabe que as funções 
servem para que a gente isole

00:00:25.179 --> 00:00:28.017
e reaproveite o código,

00:00:28.017 --> 00:00:30.855
e que a gente também pode 
informar parâmetros para elas.

00:00:30.855 --> 00:00:32.725
Não há necessariamente
uma quantidade limite

00:00:32.725 --> 00:00:34.632
de parâmetros
que a gente pode informar,

00:00:34.632 --> 00:00:36.826
desde que a gente especifique
eles corretamente

00:00:36.826 --> 00:00:39.020
na assinatura do método.

00:00:39.020 --> 00:00:39.986
E calma.

00:00:39.986 --> 00:00:41.538
Quando a gente fala assinatura
do método,

00:00:41.538 --> 00:00:43.223
a gente está basicamente 
falando daquela primeira linha,

00:00:43.223 --> 00:00:47.410
aonde a gente define o nome
e os parâmetros da função,

00:00:47.410 --> 00:00:51.630
que, por acaso, a gente pode
especificar quantos a gente quiser.

00:00:51.630 --> 00:00:53.643
Basta que a gente coloque 
os seus nomes adequados.

00:00:53.643 --> 00:00:55.721
Por exemplo, nome, idade
ou qualquer outra informação

00:00:55.721 --> 00:01:00.180
que a gente queira usar dentro
daquela função.

00:01:00.180 --> 00:01:01.684
E, lembra, o nome que a gente
colocar na assinatura

00:01:01.684 --> 00:01:06.390
é como a gente vai referenciá-las
dentro do bloco da função.

00:01:06.390 --> 00:01:08.330
Na maioria dos casos,
a gente vai ter bem claro

00:01:08.330 --> 00:01:10.134
quais são as informações 
que a gente precisa

00:01:10.134 --> 00:01:12.112
para executar um determinado
bloco de código

00:01:12.112 --> 00:01:14.090
dentro de uma função.

00:01:14.090 --> 00:01:15.920
E isso, na verdade, é a regra.

00:01:15.920 --> 00:01:18.006
A gente precisa saber
quais são as informações

00:01:18.006 --> 00:01:21.075
para que a gente saiba 
como lidar com elas dentro do código.

00:01:21.075 --> 00:01:23.667
Mas existem alguns
cenários em que,

00:01:23.667 --> 00:01:26.260
embora a gente saiba quais
informações a gente precisa,

00:01:26.260 --> 00:01:29.410
a gente não sabe exatamente
quantas informações vão vir.

00:01:29.410 --> 00:01:33.110
E calma, eu sei que está um pouco
confuso, mas você já já vai entender.

00:01:33.110 --> 00:01:35.582
Imagina que você tem uma função 
que tem que receber um nome

00:01:35.582 --> 00:01:38.055
e exibir uma mensagem 
com esse nome.

00:01:38.055 --> 00:01:40.450
Está bem claro aqui como
é que as coisas vão funcionar.

00:01:40.450 --> 00:01:43.090
Dentro dos parâmetros, a gente vai
ter uma variável que representa o nome

00:01:43.090 --> 00:01:45.730
e a gente vai usar
ela dentro da nossa função.

00:01:45.730 --> 00:01:46.738
Simples.

00:01:46.738 --> 00:01:50.380
Por outro lado, imagina que a gente 
vai calcular alguma média.

00:01:50.380 --> 00:01:52.510
A gente sabe como é feito
o cálculo de média.

00:01:52.510 --> 00:01:55.701
A gente soma, por exemplo,
todas as notas de um aluno

00:01:55.701 --> 00:01:59.410
e divide essa somatória 
pela quantidade de notas totais.

00:01:59.410 --> 00:02:00.492
A gente pode, sem problema nenhum,

00:02:00.492 --> 00:02:03.740
implementar uma função
que recebe dois valores.

00:02:03.740 --> 00:02:06.018
A gente vai, então, pegar
esses valores, somar,

00:02:06.018 --> 00:02:08.920
e o que der de resultado,
a gente divide por dois.

00:02:08.920 --> 00:02:10.212
Mas pensa aqui comigo.

00:02:10.212 --> 00:02:11.504
A gente está trabalhando com Python,

00:02:11.504 --> 00:02:14.145
e diversas possibilidades
estão na palma da nossa mão.

00:02:14.145 --> 00:02:16.212
Então, por que, ao invés de a gente
implementar uma função

00:02:16.212 --> 00:02:20.465
que lida com duas notas,
a gente implementa uma função

00:02:20.465 --> 00:02:21.557
que lida com qualquer 
quantidade de notas

00:02:21.557 --> 00:02:22.650
que a gente quiser informar?

00:02:22.650 --> 00:02:23.860
Vamos lá, então.

00:02:23.860 --> 00:02:25.900
Aqui no VS Code, a gente
já tem um código inicial,

00:02:25.900 --> 00:02:28.450
que é aquele nosso primeiro
exemplo que a gente comentou.

00:02:28.450 --> 00:02:31.026
A gente tem uma função simples,
que recebe um parâmetro,

00:02:31.026 --> 00:02:33.520
e ele é usado aqui para montar 
alguma mensagem.

00:02:33.520 --> 00:02:35.222
Se a gente exibir
aqui o nosso código,

00:02:35.222 --> 00:02:37.040
ou melhor, executar
o nosso código,

00:02:37.040 --> 00:02:40.030
a gente consegue ver que a mensagem
é exibida com sucesso,

00:02:40.030 --> 00:02:42.830
e na invocação da função,
a gente passa apenas um parâmetro,

00:02:42.830 --> 00:02:45.630
que no nosso caso
é o valor mundo.

00:02:45.630 --> 00:02:47.760
Olha o que acontece se a gente 
tentar passar aqui, por exemplo,

00:02:47.760 --> 00:02:49.890
um outro valor.

00:02:49.890 --> 00:02:52.610
Por exemplo, aluno,
que é uma outra string.

00:02:52.610 --> 00:02:54.815
Repara que o Python dá um erro,

00:02:54.815 --> 00:02:56.992
porque a gente especificou
que essa função recebe

00:02:56.992 --> 00:02:59.463
apenas um argumento, ou seja,
um parâmetro,

00:02:59.463 --> 00:03:01.935
mas dois foram informados.

00:03:01.935 --> 00:03:04.505
E é exatamente o que a gente
vai querer fazer já já.

00:03:04.505 --> 00:03:06.732
Eu vou começar, então,
editando o nome dessa função

00:03:06.732 --> 00:03:09.410
para que faça mais sentido
com o que a gente quer fazer.

00:03:09.410 --> 00:03:11.650
Aqui no nosso caso é fazer
o cálculo de uma média.

00:03:11.650 --> 00:03:14.565
Então eu vou vir aqui 
e vou editar o nome dela

00:03:14.565 --> 00:03:17.480
para ficar calcular média.

00:03:17.480 --> 00:03:19.427
E pronto.

00:03:19.427 --> 00:03:21.375
Ao invés de um nome,
eu vou receber as notas aqui.

00:03:21.375 --> 00:03:23.285
E é aqui que vem a chave.

00:03:23.285 --> 00:03:26.160
Quando eu especifico os meus
parâmetros dessa forma,

00:03:26.160 --> 00:03:29.010
eu estou informando para o Python 
parâmetros posicionais

00:03:29.010 --> 00:03:31.860
com uma quantidade
específica de itens.

00:03:31.860 --> 00:03:33.825
Mas agora a gente vai usar

00:03:33.825 --> 00:03:36.842
uma técnica chamada args do Python,
que permite que a gente informe para ele

00:03:36.842 --> 00:03:39.860
que esse parâmetro 
é um parâmetro especial

00:03:39.860 --> 00:03:43.005
e que vai receber uma quantidade
não exata de itens.

00:03:43.005 --> 00:03:47.030
E para isso, basta a gente colocar
o asterisco aqui no começo do nome.

00:03:47.030 --> 00:03:48.256
E pronto.

00:03:48.256 --> 00:03:50.375
A partir desse momento,

00:03:50.375 --> 00:03:52.495
o Python vai tratar essa variável não
como uma variável normal,

00:03:52.495 --> 00:03:53.739
mas sim como uma tupla,

00:03:53.739 --> 00:03:55.884
que é basicamente
uma coleção de itens

00:03:55.884 --> 00:03:58.030
que não pode ser alterada.

00:03:58.030 --> 00:04:00.430
Então, antes da gente 
implementar a nossa lógica,

00:04:00.430 --> 00:04:04.292
vamos só colocar um print aqui,
exibindo o valor dessa variável

00:04:04.292 --> 00:04:06.570
que a gente está recebendo 
nos parâmetros,

00:04:06.570 --> 00:04:08.340
para a gente ver a cara dela.

00:04:08.340 --> 00:04:11.960
Então, aqui na execução do método,
eu vou atualizar o nome também

00:04:11.960 --> 00:04:15.310
e eu vou deixar aqueles
nossos dois valores, mundo e aluno.

00:04:15.310 --> 00:04:16.896
Porque lembra,

00:04:16.896 --> 00:04:18.482
o Python é uma linguagem 
de tipo dinâmico, então,

00:04:18.482 --> 00:04:21.710
enquanto a gente não usar
os valores como se fossem números,

00:04:21.710 --> 00:04:23.540
a gente não vai ter problema nenhum.

00:04:23.540 --> 00:04:25.915
Se eu executar novamente
aqui o nosso código,

00:04:25.915 --> 00:04:28.650
a gente repara que os dois
valores estão aqui,

00:04:28.650 --> 00:04:30.800
mesmo que em apenas uma variável.

00:04:30.800 --> 00:04:32.237
E se a gente quiser,

00:04:32.237 --> 00:04:34.383
a gente pode vir aqui 
e adicionar qualquer outra coisa,

00:04:34.383 --> 00:04:36.530
como, por exemplo, aluna.

00:04:36.530 --> 00:04:37.638
Se a gente executar,
a gente vê que,

00:04:37.638 --> 00:04:41.170
mesmo sem alterar 
a definição da nossa função,

00:04:41.170 --> 00:04:42.230
aquele novo valor
que a gente formou

00:04:42.230 --> 00:04:45.710
está lá dentro também,
dentro da nossa tupla.

00:04:45.710 --> 00:04:46.675
Então, agora sim,

00:04:46.675 --> 00:04:49.510
é hora da gente implementar
a nossa lógica do cálculo da média.

00:04:49.510 --> 00:04:51.164
Então, para isso, 
a gente vai vir aqui dentro

00:04:51.164 --> 00:04:55.159
e vai começar com uma variável 
que vai ser, por exemplo,

00:04:55.159 --> 00:04:57.420
a soma, que vai
começar com zero.

00:04:57.420 --> 00:04:59.612
Eu vou implementar isso aqui
de uma forma bem simples,

00:04:59.612 --> 00:05:01.730
para que a gente entenda
como está sendo feito.

00:05:01.730 --> 00:05:04.104
Então, eu vou começar
executando um loop

00:05:04.104 --> 00:05:06.355
para cada item
daquela minha tupla.

00:05:06.355 --> 00:05:08.500
Lembra?

00:05:08.500 --> 00:05:10.645
O for permite que a gente
itere sobre vários tipos de dados,

00:05:10.645 --> 00:05:11.850
e a tupla é um deles.

00:05:11.850 --> 00:05:14.882
Se a gente fizer isso com a tupla,
ele vai passar por cada um dos itens,

00:05:14.882 --> 00:05:17.854
e a gente vai ter a oportunidade
de fazer alguma coisa com esse número.

00:05:17.854 --> 00:05:20.550
No nosso caso, eu vou passar 
dentro das notas.

00:05:20.550 --> 00:05:23.430
Para cada nota, eu vou chamar
ela de nota, aqui dentro,

00:05:23.430 --> 00:05:25.397
e eu vou especificar
a minha lista, ou a minha coleção,

00:05:25.397 --> 00:05:27.365
que no caso é uma tupla.

00:05:27.365 --> 00:05:29.812
E pronto.

00:05:29.812 --> 00:05:32.260
Aqui dentro, eu vou basicamente 
usar o operador de soma,

00:05:32.260 --> 00:05:35.610
para fazer com que o soma
receba o valor do próprio soma,

00:05:35.610 --> 00:05:39.530
mais o valor da minha nota atual,
que está dentro do meu loop.

00:05:39.530 --> 00:05:40.310
Beleza?

00:05:40.310 --> 00:05:41.070
Pronto.

00:05:41.070 --> 00:05:44.385
Nesse ponto aqui, a gente já tem
a somatória das nossas notas.

00:05:44.385 --> 00:05:46.290
Então, para terminar a lógica,

00:05:46.290 --> 00:05:48.195
basta a gente fazer a divisão 
pela quantidade de notas.

00:05:48.195 --> 00:05:52.115
Então, eu vou declarar uma outra
variável aqui, que vai ser a média.

00:05:52.115 --> 00:05:55.645
Ela vai ser basicamente
igual à minha soma,

00:05:55.645 --> 00:05:59.715
dividida pela quantidade de itens
que foram informadas naquela tupla.

00:05:59.715 --> 00:06:02.770
E para fazer isso, a gente
pode usar a função nativa len,

00:06:02.770 --> 00:06:06.860
que recebe alguma coleção e retorna
para a gente a quantidade de itens.

00:06:06.860 --> 00:06:09.345
Então, basta a gente informar 
aqui para ele a nossa variável notas,

00:06:09.345 --> 00:06:11.830
e pronto.

00:06:11.830 --> 00:06:14.660
Vou colocar aqui um return, média,

00:06:14.660 --> 00:06:17.810
para fazer com que a nossa função
retorne o valor daquele cálculo.

00:06:17.810 --> 00:06:19.950
E se a gente executar
o nosso programa de novo,

00:06:19.950 --> 00:06:22.090
hum, repara que a gente teve um erro.

00:06:22.090 --> 00:06:24.215
Isso aconteceu basicamente

00:06:24.215 --> 00:06:26.340
porque a gente mudou a implementação
da nossa função,

00:06:26.340 --> 00:06:29.570
mas esqueceu de mudar os valores
que foram informados no parâmetro.

00:06:29.570 --> 00:06:30.410
Dá uma olhada.

00:06:30.410 --> 00:06:34.510
Aqui dentro, a gente está informando
mundo, aluno e aluna, que são texto.

00:06:34.510 --> 00:06:37.475
E agora sim, a gente está lidando 
com valores numéricos.

00:06:37.475 --> 00:06:40.090
Então, basta que a gente
edite aqui esses valores.

00:06:40.090 --> 00:06:42.660
Então, vamos começar
com uma conta simples aqui.

00:06:42.660 --> 00:06:45.405
Eu vou informar a nota 5 e a nota 5.

00:06:45.405 --> 00:06:46.955
Eu vou limpar o terminal

00:06:46.955 --> 00:06:48.505
para que fique um pouco
mais simples as coisas.

00:06:48.505 --> 00:06:52.680
E se a gente rodar novamente,
novamente, o nosso aplicativo rodou,

00:06:52.680 --> 00:06:54.830
mas a gente não tem nada na tela.

00:06:54.830 --> 00:06:56.890
E isso aconteceu porque a gente 
executou a função

00:06:56.890 --> 00:06:58.950
e ela retornou o valor.

00:06:58.950 --> 00:07:00.940
Mas a gente não exibiu
isso de lugar em algum.

00:07:00.940 --> 00:07:05.400
Então, eu vou basicamente envolver
essa função dentro dos parênteses

00:07:05.400 --> 00:07:08.015
e usar a função nativa print,

00:07:08.015 --> 00:07:10.630
para que agora sim 
esse valor seja exibido.

00:07:10.630 --> 00:07:13.010
E se a gente roda de novo
com os mesmos valores,

00:07:13.010 --> 00:07:15.380
agora sim, a gente tem a média 5.

00:07:15.380 --> 00:07:19.310
E se eu acrescentar algum valor
aqui, como, por exemplo, 10,

00:07:19.310 --> 00:07:22.803
a gente tem como
resultado a média 6.

00:07:22.803 --> 00:07:25.794
6, que é o resultado
da somatória de 5,

00:07:25.794 --> 00:07:28.785
5 e 10, dividido pela
quantidade total, que é 3.

00:07:28.785 --> 00:07:32.440
E é dessa forma que a gente consegue
lidar com informações dinâmicas.

00:07:32.440 --> 00:07:33.670
Cuidado para não confundir.

00:07:33.670 --> 00:07:37.125
A gente ainda precisa especificar
quais são as variáveis.

00:07:37.125 --> 00:07:39.382
E a gente pode usar
os args em conjunto

00:07:39.382 --> 00:07:41.770
com outros tipos
de variáveis comuns,

00:07:41.770 --> 00:07:44.220
desde que a gente especifique 
as variáveis comuns no começo

00:07:44.220 --> 00:07:46.670
e deixe os args para o final.

00:07:46.670 --> 00:07:49.520
A gente usou os args aqui
para fazer o cálculo de uma média,

00:07:49.520 --> 00:07:51.137
que é um cenário 
em que realmente, talvez,

00:07:51.137 --> 00:07:55.990
a gente tenha uma quantidade dinâmica
de itens e a gente tenha que lidar com isso.

00:07:55.990 --> 00:07:59.510
E é exatamente nesse tipo de cenário
em que você vai querer usar os args.

00:07:59.510 --> 00:08:01.269
Normalmente, a gente costuma 
usar eles com listas,

00:08:01.269 --> 00:08:03.185
que vão vir de algum recurso externo,

00:08:03.185 --> 00:08:07.070
onde a gente não controla
a quantidade de itens que vai ter,

00:08:07.070 --> 00:08:08.850
mas quer lidar com todos eles.

00:08:08.850 --> 00:08:10.677
E é dessa forma que a gente 
consegue lidar

00:08:10.677 --> 00:08:13.203
com essa lista dinâmica de itens,
sem ter que necessariamente

00:08:13.203 --> 00:08:15.730
se preocupar com a quantidade informada.