Quando a gente está
implementando alguma coisa
nova, a gente nunca
constrói tudo do zero.
Então, nessa brincadeira
de reaproveitar
o que já está feito,
a gente começa a conversar
sobre função nativa
para cá e para lá, e agora
finalmente chegou
o momento da gente entender
o que são funções
para que servem e construir
a nossa primeira.
Como a gente já comentou, a gente
consegue reaproveitar bastante
coisa no desenvolvimento
e tem vários motivos
para fazer isso.
Se a gente quisesse, a gente
até poderia fazer isso
tudo do zero, mas tem alguns
problemas nessa abordagem.
Imagina que dentro da sua
aplicação, você tem
que exibir uma mensagem
para algum usuário.
Dentro dessa mensagem,
você provavelmente vai ter
o nome do usuário e alguns
elementos extras, como
um prefixo ou sufixo, alguma
coisa desse tipo. Pronto,
esse seu código vai funcionar
mais, felizmente ou,
infelizmente, mais para frente
no seu código, você
vai ter que repetir aquele
mesmo comportamento. E
conforme sua aplicação for
crescendo, provavelmente
em outros lugares você vai
ter que fazer isso também.
E não só nesse arquivo,
mas em vários outros arquivos. E
agora você já está começando
a enxergar qual que é o problema.
Não só a gente não está
conseguindo reaproveitar
aquele código, porque
ele está espalhado no meio
da nossa aplicação, como
se a gente precisar trocar
aquele comportamento
para adicionar ou remover
alguma característica,
isso vai ser muito
complicado, porque a gente
vai ter que depender
de ferramentas de busca
para procurar algum trecho
de código e então alterá-lo
em todos os lugares.
É muito fácil a gente
acabar esquecendo um ou dois
lugares e, com isso, injetar
bugs no nosso programa.
Para resolver esse problema,
a gente tem as funções,
que é a porta de entrada
para o tema de abstração.
Com elas, a gente consegue
criar blocos de código
parametrizáveis e executar
uma lógica específica
quantas vezes a gente quiser.
Funções existem basicamente
todas as linguagens,
de uma forma ou de outra.
E a característica principal
delas é isolar bloco
de código para reaproveitamento.
Sendo assim,
a gente consegue implementar
o que a gente quiser
e dar manutenção em um só
lugar do nosso código.
Se a gente precisar
alterar um comportamento,
basta alterar dentro
daquela função
e aonde ela estiver
sendo referenciada,
o comportamento vai
ser atualizado também.
legal. Agora que você
entendeu a motivação e,
mais ou menos, a ideia
por trás das funções,
vamos ver, na prática, como
que isso funciona no Python.
Então, vamos lá
para o código.
Aqui no VS Code, eu já
tenho meu arquivo main.
py criado. Então, vamos começar
definindo a nossa função.
E, para isso, eu vou usar
a palavra reservada def.
Cada linguagem de programação
tem a sua forma
de fazer e é assim
que a gente faz no Python.
Eu vou começar, então,
aqui colocando o nome
da minha função, que vai
ser exatamente minha função.
A gente pode mudar isso no
futuro sem problema nenhum.
E, para que o Python entenda,
de fato, que isso é uma função,
eu vou colocar aqui
os parênteses e os dois pontos.
Pronto.
A partir de agora, eu estou livre
para desenvolver
o corpo da minha função.
Ou seja, o que eu quero
que seja executado quando
essa função for invocada.
No nosso exemplo, a gente vai
colocar apenas um print,
escrevendo alguma mensagem
simples, como, por exemplo,
olá, aluno. E salvar o arquivo.
Nesse momento, a gente já pode
executar a nossa aplicação
usando o python.exe
e o nome do arquivo.
Veja só. Aqui no terminal,
eu vou escrever python.
exe, ponto barra e o
nome do meu arquivo.
Ponto barra, main.py. E se eu der
um enter, repara que a aplicação
até executou, mas não aconteceu
nada de muito interessante.
Isso foi, basicamente,
porque eu declarei a minha
função, mas eu não invoquei
ela em lugar algum.
Lembra, funções são
blocos de abstração.
Eu consigo escrever código
lá dentro, mas ele só
é executado, de fato,
quando eu invoco
essa função.
Então, vamos lá aqui no nosso código.
E aqui embaixo, eu vou
invocar essa função.
E para fazer isso,
basta eu executar o nome
dessa função e colocar
aqui os parênteses.
Dessa forma, eu estou
pedindo para o python
para que ele pegue e execute
aquele bloco de código.
Se eu rodar novamente o meu
programa, dessa vez sim,
a gente tem a mensagem
olá, alunos, sendo exibida.
E bacana, a nossa função está
funcionando, mas ela ainda
não tem muita funcionalidade
na nossa aplicação.
Porque uma das
características de funções
é ter a capacidade
de ser parametrizada.
Ou seja, a gente deve,
dependendo do cenário, conseguir
manipular o comportamento dela
baseado em informações externas.
E isso a gente faz justamente através
de parâmetros. No Python, a gente
consegue definir uma lista
de parâmetros que essa função recebe,
semelhante à própria
funcionativa print.
Se a gente quiser
executar ela, a gente
tem que mandar
um string, ou seja,
um texto que vai ser
exibido no terminal.
É assim que a gente controla
o comportamento da função print,
parametrizando para ela a mensagem
que a gente quer que seja exibida.
No nosso caso, o que a gente vai
fazer é adicionar um parâmetro
para que a gente informe
o nome que a gente
quer que esteja
dentro da mensagem.
Entendeu? Então, vamos lá.
Aqui no nosso código, então,
eu vou começar entre os parênteses,
colocando o meu parâmetro,
que eu vou chamar de nome.
E no Python, a gente
tem a tipagem dinâmica.
Isso significa que eu posso
deixar o meu código dessa forma,
e em tempo de execução, o Python
vai saber o tipo dessa variável.
Mas caso eu queira deixar
mais claro para algum
desenvolvedor que pegar
o nosso código,
eu posso colocar
aqui do lado,
na frente dos dois
pontos, o tipo str.
Lembra, isso não vai mudar
na prática nada dentro da linguagem,
mas vai fazer com que alguém
que pegue meu código
entenda que eu estou esperando
que ele mande um string.
Se ele mandar um número, o Python
não vai reclamar nesse momento.
Mas eu estou informando
para ele que o comportamento
esperado é que ele mande
um texto.
Tá bom? Então vamos lá.
Agora que dentro
do contexto da minha função
eu tenho essa variável,
eu posso usar ela.
Então eu vou basicamente
copiar ela aqui
e remover a palavra
aluno da minha mensagem,
porque agora eu vou fazer
uma concatenação simples.
E para isso, eu vou
colocar aqui na frente
do sinal
de mais a variável nome.
E vamos ver o que acontece
se eu executar
o meu código do jeito
que ele está.
Pronto! A gente agora tem
um erro, porque eu defini
um parâmetro
e ele é um parâmetro posicional.
Ou seja, eu posso definir
vários parâmetros.
E a ordem com que eu passar
eles vai ser a ordem
com que o Python vai alocá-los
dentro das variáveis. Vamos lá.
Isso significa que se eu tivesse
uma outra variável aqui,
por exemplo, idade, eu teria
que passar aqui embaixo,
dentro da invocação
da minha função, a primeira
variável que é o nome.
Por exemplo, aluno.
E se eu quiser passar idade,
eu coloco aqui na frente.
Repara que a própria IDE já
vai dando dicas para a gente
de como que a gente está
esperando receber os valores.
Mas no nosso cenário, a gente
só vai ter um parâmetro.
Então eu vou
remover a idade.
E se a gente executa novamente
o nosso código, agora sim.
A gente tem a mesma mensagem
de antes, mas um pouco diferente.
Porque essa mensagem agora,
ela está parametrizável.
Ou seja, a gente
consegue controlar
o comportamento daquela
função do lado de fora.
E se eu quiser usar
essa função quantas vezes
eu quiser, eu posso
sem problema nenhum.
Então, imagina, por exemplo,
que aqui embaixo
eu vou querer executar
ela mais duas vezes.
Só que dessa vez,
colocando aluna, e aqui
embaixo, talvez você esteja
sentindo falta disso.
Então, mundo, se
eu limpar o meu terminal
e executar novamente
a aplicação,
a gente vê que a gente tem
as três exibições daquela função,
sendo que cada
uma delas reaproveitou
o código que a gente
definiu na função,
mas foi
parametrizado
para que o comportamento
fosse diferente.
Incrível, né?
A gente construiu uma função simples,
mas as funções estão
por todo lugar na linguagem.
Sejam funções nativas
ou funções de pacote que a gente
vai uma hora ou outra
até que acabar usando.
Dá uma explorada nesse código aqui
e tenta melhorar ele um pouco.
Tenta adicionar um outro
parâmetro, um outro tipo,
faz condicionais lá
dentro, loops, quem sabe.
Experimenta.
Ganha afinidade com essa sintaxe
aqui e vamos ver
até onde você chega.
E aí.