-
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
-
mas 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
o 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_funcao.
-
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 .\",
-
e o nome do meu arquivo.
-
.\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.
-
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.
-
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.
