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.