vimeo.com/.../1064653407

A gente deu nosso primeiro passo
no reaproveitamento de código

com as funções e entendeu
também como usar os parâmetros.

Mas agora está na hora
da gente dar uma olhada

em um outro tipo de parâmetro
que permite que a gente informe dados

de uma forma um pouco diferente.

Está na hora da gente
olhar um pouco os args.

A gente já sabe que as funções
servem para que a gente isole

e reaproveite o código,

e que a gente também pode
informar parâmetros para elas.

Não há necessariamente
uma quantidade limite

de parâmetros
que a gente pode informar,

desde que a gente especifique
eles corretamente

na assinatura do método.

E calma.

Quando a gente fala assinatura
do método,

a gente está basicamente
falando daquela primeira linha,

aonde a gente define o nome
e os parâmetros da função,

que, por acaso, a gente pode
especificar quantos a gente quiser.

Basta que a gente coloque
os seus nomes adequados.

Por exemplo, nome, idade
ou qualquer outra informação

que a gente queira usar dentro
daquela função.

E, lembra, o nome que a gente
colocar na assinatura

é como a gente vai referenciá-las
dentro do bloco da função.

Na maioria dos casos,
a gente vai ter bem claro

quais são as informações
que a gente precisa

para executar um determinado
bloco de código

dentro de uma função.

E isso, na verdade, é a regra.

A gente precisa saber
quais são as informações

para que a gente saiba
como lidar com elas dentro do código.

Mas existem alguns
cenários em que,

embora a gente saiba quais
informações a gente precisa,

a gente não sabe exatamente
quantas informações vão vir.

E calma, eu sei que está um pouco
confuso, mas você já já vai entender.

Imagina que você tem uma função
que tem que receber um nome

e exibir uma mensagem
com esse nome.

Está bem claro aqui como
é que as coisas vão funcionar.

Dentro dos parâmetros, a gente vai
ter uma variável que representa o nome

e a gente vai usar
ela dentro da nossa função.

Simples.

Por outro lado, imagina que a gente
vai calcular alguma média.

A gente sabe como é feito
o cálculo de média.

A gente soma, por exemplo,
todas as notas de um aluno

e divide essa somatória
pela quantidade de notas totais.

A gente pode, sem problema nenhum,

implementar uma função
que recebe dois valores.

A gente vai, então, pegar
esses valores, somar,

e o que der de resultado,
a gente divide por dois.

Mas pensa aqui comigo.

A gente está trabalhando com Python,

e diversas possibilidades
estão na palma da nossa mão.

Então, por que, ao invés de a gente
implementar uma função

que lida com duas notas,
a gente implementa uma função

que lida com qualquer
quantidade de notas

que a gente quiser informar?

Vamos lá, então.

Aqui no VS Code, a gente
já tem um código inicial,

que é aquele nosso primeiro
exemplo que a gente comentou.

A gente tem uma função simples,
que recebe um parâmetro,

e ele é usado aqui para montar
alguma mensagem.

Se a gente exibir
aqui o nosso código,

ou melhor, executar
o nosso código,

a gente consegue ver que a mensagem
é exibida com sucesso,

e na invocação da função,
a gente passa apenas um parâmetro,

que no nosso caso
é o valor mundo.

Olha o que acontece se a gente
tentar passar aqui, por exemplo,

um outro valor.

Por exemplo, aluno,
que é uma outra string.

Repara que o Python dá um erro,

porque a gente especificou
que essa função recebe

apenas um argumento, ou seja,
um parâmetro,

mas dois foram informados.

E é exatamente o que a gente
vai querer fazer já já.

Eu vou começar, então,
editando o nome dessa função

para que faça mais sentido
com o que a gente quer fazer.

Aqui no nosso caso é fazer
o cálculo de uma média.

Então eu vou vir aqui
e vou editar o nome dela

para ficar calcular média.

E pronto.

Ao invés de um nome,
eu vou receber as notas aqui.

E é aqui que vem a chave.

Quando eu especifico os meus
parâmetros dessa forma,

eu estou informando para o Python
parâmetros posicionais

com uma quantidade
específica de itens.

Mas agora a gente vai usar

uma técnica chamada args do Python,
que permite que a gente informe para ele

que esse parâmetro
é um parâmetro especial

e que vai receber uma quantidade
não exata de itens.

E para isso, basta a gente colocar
o asterisco aqui no começo do nome.

E pronto.

A partir desse momento,

o Python vai tratar essa variável não
como uma variável normal,

mas sim como uma tupla,

que é basicamente
uma coleção de itens

que não pode ser alterada.

Então, antes da gente
implementar a nossa lógica,

vamos só colocar um print aqui,
exibindo o valor dessa variável

que a gente está recebendo
nos parâmetros,

para a gente ver a cara dela.

Então, aqui na execução do método,
eu vou atualizar o nome também

e eu vou deixar aqueles
nossos dois valores, mundo e aluno.

Porque lembra,

o Python é uma linguagem
de tipo dinâmico, então,

enquanto a gente não usar
os valores como se fossem números,

a gente não vai ter problema nenhum.

Se eu executar novamente
aqui o nosso código,

a gente repara que os dois
valores estão aqui,

mesmo que em apenas uma variável.

E se a gente quiser,

a gente pode vir aqui
e adicionar qualquer outra coisa,

como, por exemplo, aluna.

Se a gente executar,
a gente vê que,

mesmo sem alterar
a definição da nossa função,

aquele novo valor
que a gente formou

está lá dentro também,
dentro da nossa tupla.

Então, agora sim,

é hora da gente implementar
a nossa lógica do cálculo da média.

Então, para isso,
a gente vai vir aqui dentro

e vai começar com uma variável
que vai ser, por exemplo,

a soma, que vai
começar com zero.

Eu vou implementar isso aqui
de uma forma bem simples,

para que a gente entenda
como está sendo feito.

Então, eu vou começar
executando um loop

para cada item
daquela minha tupla.

Lembra?

O for permite que a gente
itere sobre vários tipos de dados,

e a tupla é um deles.

Se a gente fizer isso com a tupla,
ele vai passar por cada um dos itens,

e a gente vai ter a oportunidade
de fazer alguma coisa com esse número.

No nosso caso, eu vou passar
dentro das notas.

Para cada nota, eu vou chamar
ela de nota, aqui dentro,

e eu vou especificar
a minha lista, ou a minha coleção,

que no caso é uma tupla.

E pronto.

Aqui dentro, eu vou basicamente
usar o operador de soma,

para fazer com que o soma
receba o valor do próprio soma,

mais o valor da minha nota atual,
que está dentro do meu loop.

Beleza?

Pronto.

Nesse ponto aqui, a gente já tem
a somatória das nossas notas.

Então, para terminar a lógica,

basta a gente fazer a divisão
pela quantidade de notas.

Então, eu vou declarar uma outra
variável aqui, que vai ser a média.

Ela vai ser basicamente
igual à minha soma,

dividida pela quantidade de itens
que foram informadas naquela tupla.

E para fazer isso, a gente
pode usar a função nativa len,

que recebe alguma coleção e retorna
para a gente a quantidade de itens.

Então, basta a gente informar
aqui para ele a nossa variável notas,

e pronto.

Vou colocar aqui um return, média,

para fazer com que a nossa função
retorne o valor daquele cálculo.

E se a gente executar
o nosso programa de novo,

hum, repara que a gente teve um erro.

Isso aconteceu basicamente

porque a gente mudou a implementação
da nossa função,

mas esqueceu de mudar os valores
que foram informados no parâmetro.

Dá uma olhada.

Aqui dentro, a gente está informando
mundo, aluno e aluna, que são texto.

E agora sim, a gente está lidando
com valores numéricos.

Então, basta que a gente
edite aqui esses valores.

Então, vamos começar
com uma conta simples aqui.

Eu vou informar a nota 5 e a nota 5.

Eu vou limpar o terminal

para que fique um pouco
mais simples as coisas.

E se a gente rodar novamente,
novamente, o nosso aplicativo rodou,

mas a gente não tem nada na tela.

E isso aconteceu porque a gente
executou a função

e ela retornou o valor.

Mas a gente não exibiu
isso de lugar em algum.

Então, eu vou basicamente envolver
essa função dentro dos parênteses

e usar a função nativa print,

para que agora sim
esse valor seja exibido.

E se a gente roda de novo
com os mesmos valores,

agora sim, a gente tem a média 5.

E se eu acrescentar algum valor
aqui, como, por exemplo, 10,

a gente tem como
resultado a média 6.

6, que é o resultado
da somatória de 5,

5 e 10, dividido pela
quantidade total, que é 3.

E é dessa forma que a gente consegue
lidar com informações dinâmicas.

Cuidado para não confundir.

A gente ainda precisa especificar
quais são as variáveis.

E a gente pode usar
os args em conjunto

com outros tipos
de variáveis comuns,

desde que a gente especifique
as variáveis comuns no começo

e deixe os args para o final.

A gente usou os args aqui
para fazer o cálculo de uma média,

que é um cenário
em que realmente, talvez,

a gente tenha uma quantidade dinâmica
de itens e a gente tenha que lidar com isso.

E é exatamente nesse tipo de cenário
em que você vai querer usar os args.

Normalmente, a gente costuma
usar eles com listas,

que vão vir de algum recurso externo,

onde a gente não controla
a quantidade de itens que vai ter,

mas quer lidar com todos eles.

E é dessa forma que a gente
consegue lidar

com essa lista dinâmica de itens,
sem ter que necessariamente

se preocupar com a quantidade informada.