WEBVTT

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

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

00:00:13.564 --> 00:00:15.044
Mas agora está na hora
da gente dar uma olhada

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

00:00:18.384 --> 00:00:19.934
de uma forma um pouco diferente.

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

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

00:00:26.054 --> 00:00:27.904
e reaproveite o código,

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

00:00:30.744 --> 00:00:32.824
Não há necessariamente
uma quantidade limite

00:00:32.824 --> 00:00:34.774
de parâmetros
que a gente pode informar,

00:00:34.774 --> 00:00:37.274
desde que a gente especifique
eles corretamente

00:00:37.274 --> 00:00:38.884
na assinatura do método.

00:00:38.884 --> 00:00:39.674
E calma.

00:00:39.674 --> 00:00:41.424
Quando a gente fala assinatura
do método,

00:00:41.424 --> 00:00:44.234
a gente está basicamente
falando daquela primeira linha,

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

00:00:47.204 --> 00:00:51.294
que, por acaso, a gente pode
especificar quantos a gente quiser.

00:00:51.294 --> 00:00:53.764
Basta que a gente coloque
os seus nomes adequados.

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

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

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

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

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

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

00:01:10.314 --> 00:01:12.634
para executar um determinado
bloco de código

00:01:12.634 --> 00:01:13.974
dentro de uma função.

00:01:13.974 --> 00:01:15.824
E isso, na verdade, é a regra.

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

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

00:01:20.954 --> 00:01:23.134
Mas existem alguns
cenários em que,

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

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

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

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

00:01:36.064 --> 00:01:37.884
e exibir uma mensagem
com esse nome.

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

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

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

00:01:45.434 --> 00:01:46.354
Simples.

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

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

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

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

00:01:59.354 --> 00:02:01.054
A gente pode, sem problema nenhum,

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

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

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

00:02:08.784 --> 00:02:09.644
Mas pensa aqui comigo.

00:02:09.644 --> 00:02:11.414
A gente está trabalhando com Python,

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

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

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

00:02:19.264 --> 00:02:21.244
que lida com qualquer
quantidade de notas

00:02:21.244 --> 00:02:22.704
que a gente quiser informar?

00:02:22.704 --> 00:02:23.784
Vamos lá, então.

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

00:02:26.014 --> 00:02:27.964
que é aquele nosso primeiro
exemplo que a gente comentou.

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

00:02:31.054 --> 00:02:33.374
e ele é usado aqui para montar
alguma mensagem.

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

00:02:35.274 --> 00:02:36.614
ou melhor, executar
o nosso código,

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

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

00:02:43.674 --> 00:02:45.514
que no nosso caso
é o valor mundo.

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

00:02:48.654 --> 00:02:49.754
um outro valor.

00:02:49.754 --> 00:02:52.464
Por exemplo, aluno,
que é uma outra string.

00:02:52.464 --> 00:02:54.444
Repara que o Python dá um erro,

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

00:02:56.944 --> 00:02:59.974
apenas um argumento, ou seja,
um parâmetro,

00:02:59.974 --> 00:03:01.824
mas dois foram informados.

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

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

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

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

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

00:03:13.924 --> 00:03:17.394
para ficar calcular média.

00:03:17.394 --> 00:03:18.154
E pronto.

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

00:03:21.264 --> 00:03:23.144
E é aqui que vem a chave.

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

00:03:25.764 --> 00:03:29.234
eu estou informando para o Python
parâmetros posicionais

00:03:29.234 --> 00:03:31.734
com uma quantidade
específica de itens.

00:03:31.734 --> 00:03:32.994
Mas agora a gente vai usar

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

00:03:37.394 --> 00:03:39.754
que esse parâmetro
é um parâmetro especial

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

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

00:03:46.864 --> 00:03:47.494
E pronto.

00:03:47.494 --> 00:03:48.344
A partir desse momento,

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

00:03:52.364 --> 00:03:54.014
mas sim como uma tupla,

00:03:54.014 --> 00:03:56.094
que é basicamente
uma coleção de itens

00:03:56.094 --> 00:03:57.934
que não pode ser alterada.

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

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

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

00:04:06.394 --> 00:04:08.244
para a gente ver a cara dela.

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

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

00:04:15.144 --> 00:04:15.874
Porque lembra,

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

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

00:04:21.334 --> 00:04:22.954
a gente não vai ter problema nenhum.

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

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

00:04:28.524 --> 00:04:30.654
mesmo que em apenas uma variável.

00:04:30.654 --> 00:04:31.774
E se a gente quiser,

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

00:04:34.534 --> 00:04:36.344
como, por exemplo, aluna.

00:04:36.344 --> 00:04:38.024
Se a gente executar,
a gente vê que,

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

00:04:41.034 --> 00:04:42.624
aquele novo valor
que a gente formou

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

00:04:45.614 --> 00:04:46.494
Então, agora sim,

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

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

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

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

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

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

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

00:05:04.294 --> 00:05:06.234
para cada item
daquela minha tupla.

00:05:06.234 --> 00:05:06.774
Lembra?

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

00:05:10.514 --> 00:05:11.674
e a tupla é um deles.

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

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

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

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

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

00:05:26.074 --> 00:05:27.254
que no caso é uma tupla.

00:05:27.254 --> 00:05:28.034
E pronto.

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

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

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

00:05:39.444 --> 00:05:40.354
Beleza?

00:05:40.354 --> 00:05:40.964
Pronto.

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

00:05:44.284 --> 00:05:45.324
Então, para terminar a lógica,

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

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

00:05:52.014 --> 00:05:55.544
Ela vai ser basicamente
igual à minha soma,

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

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

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

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

00:06:10.734 --> 00:06:11.714
e pronto.

00:06:11.714 --> 00:06:14.514
Vou colocar aqui um return, média,

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

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

00:06:19.804 --> 00:06:21.974
hum, repara que a gente teve um erro.

00:06:21.974 --> 00:06:23.274
Isso aconteceu basicamente

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

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

00:06:29.124 --> 00:06:30.274
Dá uma olhada.

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

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

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

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

00:06:42.504 --> 00:06:45.244
Eu vou informar a nota 5 e a nota 5.

00:06:45.244 --> 00:06:46.374
Eu vou limpar o terminal

00:06:46.374 --> 00:06:48.374
para que fique um pouco
mais simples as coisas.

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

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

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

00:06:57.434 --> 00:06:58.804
e ela retornou o valor.

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

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

00:07:05.294 --> 00:07:08.324
e usar a função nativa print,

00:07:08.324 --> 00:07:09.984
para que agora sim
esse valor seja exibido.

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

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

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

00:07:18.254 --> 00:07:22.124
a gente tem como
resultado a média 6.

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

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

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

00:07:32.294 --> 00:07:33.194
Cuidado para não confundir.

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

00:07:37.004 --> 00:07:39.594
E a gente pode usar
os args em conjunto

00:07:39.594 --> 00:07:41.684
com outros tipos
de variáveis comuns,

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

00:07:44.954 --> 00:07:46.674
e deixe os args para o final.

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

00:07:49.344 --> 00:07:51.674
que é um cenário
em que realmente, talvez,

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

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

00:07:59.404 --> 00:08:02.044
Normalmente, a gente costuma
usar eles com listas,

00:08:02.044 --> 00:08:03.924
que vão vir de algum recurso externo,

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

00:08:06.944 --> 00:08:08.734
mas quer lidar com todos eles.

00:08:08.734 --> 00:08:10.594
E é dessa forma que a gente
consegue lidar

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

00:08:13.804 --> 00:08:15.584
se preocupar com a quantidade informada.