WEBVTT

00:00:07.990 --> 00:00:10.580
Quando a gente está implementando
alguma coisa nova,

00:00:10.580 --> 00:00:13.170
a gente nunca constrói 
tudo do zero.

00:00:13.170 --> 00:00:15.230
Então, nessa brincadeira 
de reaproveitar

00:00:15.230 --> 00:00:16.442
o que já está feito,

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

00:00:18.232 --> 00:00:22.352
e agora finalmente chegou
o momento da gente entender

00:00:22.352 --> 00:00:23.503
o que são funções,
para que servem

00:00:23.503 --> 00:00:25.386
e construir a nossa primeira.

00:00:25.386 --> 00:00:26.328
Como a gente já comentou,

00:00:26.328 --> 00:00:30.080
a gente consegue reaproveitar 
bastante coisa no desenvolvimento

00:00:30.080 --> 00:00:31.988
e tem vários motivos
para fazer isso.

00:00:31.988 --> 00:00:34.914
Se a gente quisesse,

00:00:34.914 --> 00:00:36.377
a gente até poderia fazer 
isso tudo do zero,

00:00:36.377 --> 00:00:37.840
mas tem alguns problemas 
nessa abordagem.

00:00:37.840 --> 00:00:39.005
Imagina que dentro 
da sua aplicação,

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

00:00:42.361 --> 00:00:43.770
Dentro dessa mensagem,

00:00:43.770 --> 00:00:45.889
você provavelmente 
vai ter o nome do usuário

00:00:45.889 --> 00:00:48.502
e alguns elementos extras, 
como um prefixo ou sufixo,

00:00:48.502 --> 00:00:49.809
alguma coisa desse tipo.

00:00:49.809 --> 00:00:51.909
Pronto, esse seu código 
vai funcionar mais,

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

00:00:54.391 --> 00:00:57.042
você vai ter que repetir 
aquele mesmo comportamento.

00:00:57.042 --> 00:00:59.830
E conforme sua aplicação 
for crescendo,

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

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

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

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

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

00:01:16.772 --> 00:01:19.207
como se a gente precisar 
trocar aquele comportamento

00:01:19.207 --> 00:01:21.464
para adicionar ou remover
alguma característica,

00:01:21.464 --> 00:01:23.786
isso vai ser muito complicado,

00:01:23.786 --> 00:01:26.212
porque a gente vai ter que depender
de ferramentas de busca

00:01:26.212 --> 00:01:28.896
para procurar algum 
trecho de código

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

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

00:01:34.347 --> 00:01:37.114
e, com isso, injetar
bugs no nosso programa.

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

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

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

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

00:01:48.641 --> 00:01:51.591
Funções existem basicamente
todas as linguagens,

00:01:51.591 --> 00:01:54.541
de uma forma ou de outra.

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

00:01:57.334 --> 00:01:58.731
para reaproveitamento.

00:01:58.731 --> 00:02:03.038
Sendo assim, a gente consegue 
implementar o que a gente quiser

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

00:02:06.150 --> 00:02:08.387
Se a gente precisar alterar 
um comportamento,

00:02:08.387 --> 00:02:10.232
basta alterar dentro 
daquela função

00:02:10.232 --> 00:02:12.078
e aonde ela estiver
sendo referenciada,

00:02:12.078 --> 00:02:14.550
o comportamento 
vai ser atualizado também.

00:02:14.550 --> 00:02:15.654
Legal.

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

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

00:02:19.493 --> 00:02:21.524
como que isso funciona no Python.

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

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

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

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

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

00:02:32.684 --> 00:02:34.848
e é assim que a gente faz no Python.

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

00:02:37.096 --> 00:02:39.345
que vai ser exatamente 
minha função.

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

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

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

00:02:47.371 --> 00:02:48.564
Pronto.

00:02:48.564 --> 00:02:50.456
A partir de agora,

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

00:02:52.348 --> 00:02:53.889
Ou seja, o que eu quero
que seja executado

00:02:53.889 --> 00:02:56.392
quando essa função for invocada.

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

00:02:59.235 --> 00:03:02.842
escrevendo alguma mensagem
simples, como, por exemplo,

00:03:02.842 --> 00:03:04.646
"olá, aluno".

00:03:04.646 --> 00:03:06.450
E salvar o arquivo.

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

00:03:09.563 --> 00:03:11.860
usando o python.exe
e o nome do arquivo.

00:03:11.860 --> 00:03:13.581
Veja só.

00:03:13.581 --> 00:03:16.555
Aqui no terminal,
eu vou escrever python.exe,

00:03:16.555 --> 00:03:19.530
ponto barra e o nome do meu arquivo.

00:03:19.530 --> 00:03:21.572
Ponto barra, main.py.

00:03:21.572 --> 00:03:24.661
E se eu der um enter,

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

00:03:26.205 --> 00:03:27.750
mas não aconteceu nada 
de muito interessante.

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

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

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

00:03:35.298 --> 00:03:36.699
Eu consigo escrever 
código lá dentro,

00:03:36.699 --> 00:03:38.520
mas ele só é executado, 
de fato,

00:03:38.520 --> 00:03:40.877
quando eu invoco 
essa função.

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

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

00:03:46.185 --> 00:03:47.424
Para fazer isso,

00:03:47.424 --> 00:03:49.427
basta eu executar 
o nome dessa função

00:03:49.427 --> 00:03:51.430
e colocar aqui os parênteses.

00:03:51.430 --> 00:03:53.438
Dessa forma, eu estou
pedindo para o python

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

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

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

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

00:04:04.018 --> 00:04:06.154
mas ela ainda não tem 
muita funcionalidade

00:04:06.154 --> 00:04:08.290
na nossa aplicação.

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

00:04:10.943 --> 00:04:13.670
é ter a capacidade
de ser parametrizada.

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

00:04:15.392 --> 00:04:18.328
conseguir manipular 
o comportamento dela

00:04:18.328 --> 00:04:21.265
baseado em informações externas.

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

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

00:04:25.976 --> 00:04:28.770
que essa função recebe,

00:04:28.770 --> 00:04:30.827
semelhante à própria
funcionativa print.

00:04:30.827 --> 00:04:31.836
Se a gente quiser 
executar ela,

00:04:31.836 --> 00:04:34.584
a gente tem que mandar
um string, ou seja,

00:04:34.584 --> 00:04:37.155
um texto que vai ser
exibido no terminal.

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

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

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

00:04:47.426 --> 00:04:49.588
para que a gente informe
o nome que a gente

00:04:49.588 --> 00:04:51.750
quer que esteja
dentro da mensagem.

00:04:51.750 --> 00:04:52.567
Entendeu?

00:04:52.567 --> 00:04:53.385
Então, vamos lá.

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

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

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

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

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

00:05:09.190 --> 00:05:11.240
Mas caso eu queira deixar
mais claro para algum desenvolvedor

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

00:05:15.240 --> 00:05:18.550
na frente dos dois pontos, 
o tipo str.

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

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

00:05:24.300 --> 00:05:26.850
entenda que eu estou esperando
que ele mande um string.

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

00:05:30.540 --> 00:05:32.565
Mas eu estou informando para ele 
que o comportamento esperado

00:05:32.565 --> 00:05:34.590
é que ele mande um texto.

00:05:34.590 --> 00:05:35.950
Tá bom? Então vamos lá.

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

00:05:38.340 --> 00:05:40.730
eu posso usar ela.

00:05:40.730 --> 00:05:43.090
Então eu vou basicamente
copiar ela aqui

00:05:43.090 --> 00:05:45.450
e remover a palavra aluno 
da minha mensagem,

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

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

00:05:49.865 --> 00:05:52.010
a variável nome.

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

00:05:53.890 --> 00:05:55.770
do jeito que ele está.

00:05:55.770 --> 00:05:57.367
Pronto.

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

00:05:59.723 --> 00:06:02.080
e ele é um parâmetro posicional.

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

00:06:04.536 --> 00:06:07.235
A ordem com que eu passar
eles vai ser a ordem

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

00:06:09.257 --> 00:06:11.280
Vamos lá.

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

00:06:14.420 --> 00:06:18.330
por exemplo, idade, eu teria
que passar aqui embaixo,

00:06:18.330 --> 00:06:19.866
dentro da invocação
da minha função,

00:06:19.866 --> 00:06:22.178
a primeira variável 
que é o nome.

00:06:22.178 --> 00:06:24.490
Por exemplo, aluno.

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

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

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

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

00:06:35.402 --> 00:06:37.280
Então eu vou remover a idade.

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

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

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

00:06:46.570 --> 00:06:48.990
Ou seja, a gente consegue 
controlar o comportamento

00:06:48.990 --> 00:06:51.410
daquela função do lado de fora.

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

00:06:53.635 --> 00:06:55.860
eu posso sem problema nenhum.

00:06:55.860 --> 00:06:57.860
Então, imagina, por exemplo,
que aqui embaixo

00:06:57.860 --> 00:07:00.040
eu vou querer executar
ela mais duas vezes.

00:07:00.040 --> 00:07:01.528
Só que dessa vez,
colocando aluna,

00:07:01.528 --> 00:07:04.099
e aqui embaixo,

00:07:04.099 --> 00:07:06.670
talvez você esteja
sentindo falta disso.

00:07:06.670 --> 00:07:07.963
Então, mundo,

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

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

00:07:14.730 --> 00:07:16.735
sendo que cada uma delas 
reaproveitou o código

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

00:07:19.784 --> 00:07:22.290
para que o comportamento
fosse diferente.

00:07:22.290 --> 00:07:23.659
Incrível, né?

00:07:23.659 --> 00:07:25.029
A gente construiu uma função simples,

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

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

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

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

00:07:36.290 --> 00:07:39.030
Tenta adicionar um outro parâmetro, 
um outro tipo,

00:07:39.030 --> 00:07:41.770
faz condicionais lá dentro, 
loops, quem sabe.

00:07:41.770 --> 00:07:42.845
Experimenta.

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