vimeo.com/.../1064653172

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
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 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í.