WEBVTT

00:00:03.074 --> 00:00:10.194
Quando a gente está implementando
alguma coisa nova,

00:00:10.194 --> 00:00:13.074
a gente nunca constrói
tudo do zero.

00:00:13.074 --> 00:00:14.694
Então, nessa brincadeira
de reaproveitar

00:00:14.694 --> 00:00:15.474
o que já está feito,

00:00:15.474 --> 00:00:19.544
a gente começa a conversar sobre
função nativa para cá e para lá,

00:00:19.544 --> 00:00:21.914
e agora finalmente chegou
o momento da gente entender

00:00:21.914 --> 00:00:23.674
o que são funções,
para que servem

00:00:23.674 --> 00:00:25.684
e construir a nossa primeira.

00:00:25.684 --> 00:00:27.024
Como a gente já comentou,

00:00:27.024 --> 00:00:30.174
a gente consegue reaproveitar
bastante coisa no desenvolvimento

00:00:30.174 --> 00:00:32.034
e tem vários motivos
para fazer isso.

00:00:32.034 --> 00:00:32.774
Se a gente quisesse,

00:00:32.774 --> 00:00:35.384
a gente até poderia fazer
isso tudo do zero,

00:00:35.384 --> 00:00:38.284
mas tem alguns problemas
nessa abordagem.

00:00:38.284 --> 00:00:39.794
Imagina que dentro
da sua aplicação,

00:00:39.794 --> 00:00:42.394
você tem que exibir uma mensagem
para algum usuário.

00:00:42.394 --> 00:00:43.354
Dentro dessa mensagem,

00:00:43.354 --> 00:00:45.914
você provavelmente
vai ter o nome do usuário

00:00:45.914 --> 00:00:49.494
e alguns elementos extras,
como um prefixo ou sufixo,

00:00:49.494 --> 00:00:51.134
alguma coisa desse tipo.

00:00:51.134 --> 00:00:54.264
Pronto, esse seu código
vai funcionar mais,

00:00:54.264 --> 00:00:57.264
felizmente ou, infelizmente,
mais para frente no seu código,

00:00:57.264 --> 00:01:00.224
você vai ter que repetir
aquele mesmo comportamento.

00:01:00.224 --> 00:01:02.414
E conforme sua aplicação
for crescendo,

00:01:02.414 --> 00:01:05.464
provavelmente em outros lugares
você vai ter que fazer isso também.

00:01:05.464 --> 00:01:08.494
E não só nesse arquivo,
mas em vários outros arquivos.

00:01:08.494 --> 00:01:11.704
E agora você já está começando
a enxergar qual que é o problema.

00:01:11.704 --> 00:01:14.964
Não só a gente não está conseguindo
reaproveitar aquele código,

00:01:14.964 --> 00:01:17.504
porque ele está espalhado
no meio da nossa aplicação,

00:01:17.504 --> 00:01:19.994
como se a gente precisar
trocar aquele comportamento

00:01:19.994 --> 00:01:22.734
para adicionar ou remover
alguma característica,

00:01:22.734 --> 00:01:24.454
isso vai ser muito complicado,

00:01:24.454 --> 00:01:26.904
porque a gente vai ter que depender
de ferramentas de busca

00:01:26.904 --> 00:01:28.944
para procurar algum
trecho de código

00:01:28.944 --> 00:01:31.484
e então alterá-lo
em todos os lugares.

00:01:31.484 --> 00:01:34.434
É muito fácil a gente acabar
esquecendo um ou dois lugares

00:01:34.434 --> 00:01:36.904
e, com isso, injetar
bugs no nosso programa.

00:01:36.904 --> 00:01:39.674
Para resolver esse problema,
a gente tem as funções,

00:01:39.674 --> 00:01:42.864
que é a porta de entrada
para o tema de abstração.

00:01:42.864 --> 00:01:46.924
Com elas, a gente consegue criar blocos
de código parametrizáveis

00:01:46.924 --> 00:01:50.534
e executar uma lógica específica
quantas vezes a gente quiser.

00:01:50.534 --> 00:01:53.284
Funções existem basicamente
todas as linguagens,

00:01:53.284 --> 00:01:54.834
de uma forma ou de outra.

00:01:54.834 --> 00:01:58.524
E a característica principal
delas é isolar bloco de código

00:01:58.524 --> 00:02:00.414
para reaproveitamento.

00:02:00.414 --> 00:02:03.594
Sendo assim, a gente consegue
implementar o que a gente quiser

00:02:03.594 --> 00:02:06.024
e dar manutenção
em um só lugar do nosso código.

00:02:06.024 --> 00:02:08.004
Se a gente precisar alterar
um comportamento,

00:02:08.004 --> 00:02:10.204
basta alterar dentro
daquela função

00:02:10.204 --> 00:02:12.284
e aonde ela estiver
sendo referenciada,

00:02:12.284 --> 00:02:14.444
o comportamento
vai ser atualizado também.

00:02:14.444 --> 00:02:15.014
Legal.

00:02:15.014 --> 00:02:17.404
Agora que você entendeu a motivação
e, mais ou menos,

00:02:17.404 --> 00:02:19.924
a ideia por trás das funções,
vamos ver, na prática,

00:02:19.924 --> 00:02:21.574
como que isso funciona no Python.

00:02:21.574 --> 00:02:22.964
Então, vamos lá para o código.

00:02:22.964 --> 00:02:25.684
Aqui no VS Code, eu já tenho
o meu arquivo main.py criado.

00:02:25.684 --> 00:02:27.824
Então, vamos começar
definindo a nossa função.

00:02:27.824 --> 00:02:30.664
E, para isso, eu vou usar
a palavra reservada def.

00:02:30.664 --> 00:02:32.994
Cada linguagem de programação
tem a sua forma de fazer

00:02:32.994 --> 00:02:34.644
e é assim que a gente faz no Python.

00:02:34.644 --> 00:02:37.554
Eu vou começar, então, aqui colocando
o nome da minha função,

00:02:37.554 --> 00:02:39.644
que vai ser exatamente
minha função.

00:02:39.644 --> 00:02:42.224
A gente pode mudar isso
no futuro sem problema nenhum.

00:02:42.224 --> 00:02:44.364
E, para que o Python entenda,
de fato, que isso é uma função,

00:02:44.364 --> 00:02:47.624
eu vou colocar aqui
os parênteses e os dois pontos.

00:02:47.624 --> 00:02:48.254
Pronto.

00:02:48.254 --> 00:02:49.014
A partir de agora,

00:02:49.014 --> 00:02:52.074
eu estou livre para desenvolver
o corpo da minha função.

00:02:52.074 --> 00:02:54.464
Ou seja, o que eu quero
que seja executado

00:02:54.464 --> 00:02:56.474
quando essa função for invocada.

00:02:56.474 --> 00:02:59.374
No nosso exemplo, a gente vai
colocar apenas um print,

00:02:59.374 --> 00:03:02.344
escrevendo alguma mensagem
simples, como, por exemplo,

00:03:02.344 --> 00:03:04.734
"olá, aluno".

00:03:04.734 --> 00:03:06.344
E salvar o arquivo.

00:03:06.344 --> 00:03:09.154
Nesse momento, a gente já pode
executar a nossa aplicação

00:03:09.154 --> 00:03:11.714
usando o python.exe
e o nome do arquivo.

00:03:11.714 --> 00:03:12.634
Veja só.

00:03:12.634 --> 00:03:15.844
Aqui no terminal,
eu vou escrever python.exe,

00:03:15.844 --> 00:03:19.404
ponto barra e o nome do meu arquivo.

00:03:19.404 --> 00:03:21.474
Ponto barra, main.py.

00:03:21.474 --> 00:03:22.534
E se eu der um enter,

00:03:22.534 --> 00:03:25.124
repara que a aplicação
até executou,

00:03:25.124 --> 00:03:27.644
mas não aconteceu nada
de muito interessante.

00:03:27.644 --> 00:03:30.384
Isso foi, basicamente,
porque eu declarei a minha função,

00:03:30.384 --> 00:03:32.674
mas eu não invoquei
ela em lugar algum.

00:03:32.674 --> 00:03:35.704
Lembra, funções são
blocos de abstração.

00:03:35.704 --> 00:03:37.944
Eu consigo escrever
código lá dentro,

00:03:37.944 --> 00:03:39.694
mas ele só é executado,
de fato,

00:03:39.694 --> 00:03:41.544
quando eu invoco
essa função.

00:03:41.544 --> 00:03:43.694
Então, vamos lá,
aqui no nosso código.

00:03:43.694 --> 00:03:46.114
E aqui embaixo, eu vou
invocar essa função.

00:03:46.114 --> 00:03:46.904
Para fazer isso,

00:03:46.904 --> 00:03:49.564
basta eu executar
o nome dessa função

00:03:49.564 --> 00:03:51.264
e colocar aqui os parênteses.

00:03:51.264 --> 00:03:53.174
Dessa forma, eu estou
pedindo para o python

00:03:53.174 --> 00:03:56.134
para que ele pegue e execute
aquele bloco de código.

00:03:56.134 --> 00:03:59.054
Se eu rodar novamente
o meu programa, dessa vez sim,

00:03:59.054 --> 00:04:02.494
a gente tem a mensagem
"olá, alunos", sendo exibida.

00:04:02.494 --> 00:04:04.904
E bacana, a nossa função
está funcionando,

00:04:04.904 --> 00:04:06.854
mas ela ainda não tem
muita funcionalidade

00:04:06.854 --> 00:04:08.164
na nossa aplicação.

00:04:08.164 --> 00:04:10.864
Porque uma das
características de funções

00:04:10.864 --> 00:04:13.524
é ter a capacidade
de ser parametrizada.

00:04:13.524 --> 00:04:16.614
Ou seja, a gente deve,
dependendo do cenário,

00:04:16.614 --> 00:04:19.054
conseguir manipular
o comportamento dela

00:04:19.054 --> 00:04:21.134
baseado em informações externas.

00:04:21.134 --> 00:04:24.324
E isso a gente faz justamente através
de parâmetros.

00:04:24.324 --> 00:04:27.094
No Python, a gente consegue definir
uma lista de parâmetros

00:04:27.094 --> 00:04:28.624
que essa função recebe,

00:04:28.624 --> 00:04:31.134
semelhante à própria
funcionativa print.

00:04:31.134 --> 00:04:32.264
Se a gente quiser
executar ela,

00:04:32.264 --> 00:04:34.384
a gente tem que mandar
um string, ou seja,

00:04:34.384 --> 00:04:37.074
um texto que vai ser
exibido no terminal.

00:04:37.074 --> 00:04:40.614
É assim que a gente controla
o comportamento da função print,

00:04:40.614 --> 00:04:44.104
parametrizando para ela a mensagem
que a gente quer que seja exibida.

00:04:44.104 --> 00:04:47.714
No nosso caso, o que a gente
vai fazer é adicionar um parâmetro

00:04:47.714 --> 00:04:49.624
para que a gente informe
o nome que a gente

00:04:49.624 --> 00:04:51.524
quer que esteja
dentro da mensagem.

00:04:51.524 --> 00:04:51.774
Entendeu?

00:04:51.774 --> 00:04:53.254
Então, vamos lá.

00:04:53.254 --> 00:04:55.874
Aqui no nosso código, então,
eu vou começar entre os parênteses,

00:04:55.874 --> 00:04:59.374
colocando o meu parâmetro,
que eu vou chamar de nome.

00:04:59.374 --> 00:05:01.714
E no Python, a gente
tem a tipagem dinâmica.

00:05:01.714 --> 00:05:05.324
Isso significa que eu posso
deixar o meu código dessa forma,

00:05:05.324 --> 00:05:09.054
e em tempo de execução, o Python
vai saber o tipo dessa variável.

00:05:09.054 --> 00:05:11.884
Mas caso eu queira deixar
mais claro para algum desenvolvedor

00:05:11.884 --> 00:05:14.864
que pegar o nosso código,
eu posso colocar aqui do lado,

00:05:14.864 --> 00:05:18.434
na frente dos dois pontos,
o tipo str.

00:05:18.434 --> 00:05:22.174
Lembra, isso não vai mudar
na prática nada dentro da linguagem,

00:05:22.174 --> 00:05:24.084
mas vai fazer com que alguém
que pegue meu código

00:05:24.084 --> 00:05:26.684
entenda que eu estou esperando
que ele mande um string.

00:05:26.684 --> 00:05:30.404
Se ele mandar um número, o Python
não vai reclamar nesse momento.

00:05:30.404 --> 00:05:33.034
Mas eu estou informando para ele
que o comportamento esperado

00:05:33.034 --> 00:05:34.434
é que ele mande um texto.

00:05:34.434 --> 00:05:36.084
Tá bom? Então vamos lá.

00:05:36.084 --> 00:05:39.264
Agora que dentro do contexto
da minha função eu tenho essa variável,

00:05:39.264 --> 00:05:40.014
eu posso usar ela.

00:05:40.014 --> 00:05:42.694
Então eu vou basicamente
copiar ela aqui

00:05:42.694 --> 00:05:45.234
e remover a palavra aluno
da minha mensagem,

00:05:45.234 --> 00:05:47.604
porque agora eu vou fazer
uma concatenação simples.

00:05:47.604 --> 00:05:50.674
E para isso, eu vou colocar
aqui na frente do sinal de mais

00:05:50.674 --> 00:05:51.904
a variável nome.

00:05:51.904 --> 00:05:54.244
E vamos ver o que acontece
se eu executar o meu código

00:05:54.244 --> 00:05:55.634
do jeito que ele está.

00:05:55.634 --> 00:05:55.924
Pronto.

00:05:55.924 --> 00:05:59.664
A gente agora tem um erro,
porque eu defini um parâmetro

00:05:59.664 --> 00:06:01.964
e ele é um parâmetro posicional.

00:06:01.964 --> 00:06:04.694
Ou seja, eu posso definir
vários parâmetros.

00:06:04.694 --> 00:06:07.064
A ordem com que eu passar
eles vai ser a ordem

00:06:07.064 --> 00:06:10.124
com que o Python vai alocá-los
dentro das variáveis.

00:06:10.124 --> 00:06:11.174
Vamos lá.

00:06:11.174 --> 00:06:13.974
Isso significa que se eu tivesse
uma outra variável aqui,

00:06:13.974 --> 00:06:18.254
por exemplo, idade, eu teria
que passar aqui embaixo,

00:06:18.254 --> 00:06:20.584
dentro da invocação
da minha função,

00:06:20.584 --> 00:06:22.154
a primeira variável
que é o nome.

00:06:22.154 --> 00:06:24.364
Por exemplo, aluno.

00:06:24.364 --> 00:06:27.354
E se eu quiser passar idade,
eu coloco aqui na frente.

00:06:27.354 --> 00:06:29.844
Repara que a própria IDE
já vai dando dicas para a gente

00:06:29.844 --> 00:06:32.434
de como que a gente está
esperando receber os valores.

00:06:32.434 --> 00:06:35.524
Mas no nosso cenário, a gente
só vai ter um parâmetro.

00:06:35.524 --> 00:06:37.154
Então eu vou remover a idade.

00:06:37.154 --> 00:06:40.404
E se a gente executa novamente
o nosso código, agora sim.

00:06:40.404 --> 00:06:43.774
A gente tem a mesma mensagem
de antes, mas um pouco diferente.

00:06:43.774 --> 00:06:46.464
Porque essa mensagem agora,
ela está parametrizável.

00:06:46.464 --> 00:06:49.274
Ou seja, a gente consegue
controlar o comportamento

00:06:49.274 --> 00:06:51.304
daquela função do lado de fora.

00:06:51.304 --> 00:06:54.254
E se eu quiser usar essa função
quantas vezes eu quiser,

00:06:54.254 --> 00:06:55.234
eu posso sem problema nenhum.

00:06:55.234 --> 00:06:57.824
Então, imagina, por exemplo,
que aqui embaixo

00:06:57.824 --> 00:06:59.914
eu vou querer executar
ela mais duas vezes.

00:06:59.914 --> 00:07:03.624
Só que dessa vez,
colocando aluna,

00:07:03.624 --> 00:07:04.704
e aqui embaixo,

00:07:04.704 --> 00:07:06.524
talvez você esteja
sentindo falta disso.

00:07:06.524 --> 00:07:07.914
Então, mundo,

00:07:07.914 --> 00:07:11.624
se eu limpar o meu terminal
e executar novamente a aplicação,

00:07:11.624 --> 00:07:14.534
a gente vê que a gente tem
as três exibições daquela função,

00:07:14.534 --> 00:07:17.004
sendo que cada uma delas
reaproveitou o código

00:07:17.004 --> 00:07:19.884
que a gente definiu na função,
mas foi parametrizado

00:07:19.884 --> 00:07:22.174
para que o comportamento
fosse diferente.

00:07:22.174 --> 00:07:23.104
Incrível, né?

00:07:23.104 --> 00:07:25.044
A gente construiu uma função simples,

00:07:25.044 --> 00:07:27.744
mas as funções estão
por todo lugar na linguagem.

00:07:27.744 --> 00:07:30.544
Sejam funções nativas
ou funções de pacote que a gente

00:07:30.544 --> 00:07:32.704
vai uma hora ou outra
até que acabar usando.

00:07:32.704 --> 00:07:36.144
Dá uma explorada nesse código aqui
e tenta melhorar ele um pouco.

00:07:36.144 --> 00:07:38.504
Tenta adicionar um outro parâmetro,
um outro tipo,

00:07:38.504 --> 00:07:41.384
faz condicionais lá dentro,
loops, quem sabe.

00:07:41.384 --> 00:07:42.224
Experimenta.

00:07:42.224 --> 00:07:45.504
Ganha afinidade com essa sintaxe aqui
e vamos ver até onde você chega.