WEBVTT

00:00:07.990 --> 00:00:10.440
Quando a gente está
implementando alguma coisa

00:00:10.440 --> 00:00:13.170
nova, 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:17.654
o que já está feito,
a gente começa a conversar

00:00:17.654 --> 00:00:20.022
sobre função nativa
para cá e para lá, e agora

00:00:20.022 --> 00:00:22.352
finalmente chegou
o momento da gente entender

00:00:22.352 --> 00:00:24.655
o que são funções
para que servem e construir

00:00:24.655 --> 00:00:27.270
a nossa primeira.
Como a gente já comentou, a gente

00:00:27.270 --> 00:00:30.080
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.826
Se a gente quisesse, a gente
até poderia fazer isso

00:00:34.826 --> 00:00:37.840
tudo do zero, mas tem alguns
problemas nessa abordagem.

00:00:37.840 --> 00:00:40.170
Imagina que dentro da sua
aplicação, você tem

00:00:40.170 --> 00:00:42.361
que exibir uma mensagem
para algum usuário.

00:00:42.361 --> 00:00:45.179
Dentro dessa mensagem,
você provavelmente vai ter

00:00:45.179 --> 00:00:48.009
o nome do usuário e alguns
elementos extras, como

00:00:48.009 --> 00:00:51.116
um prefixo ou sufixo, alguma
coisa desse tipo. Pronto,

00:00:51.116 --> 00:00:54.009
esse seu código vai funcionar
mais, felizmente ou,

00:00:54.009 --> 00:00:56.873
infelizmente, mais para frente
no seu código, você

00:00:56.873 --> 00:00:59.693
vai ter que repetir aquele
mesmo comportamento. E

00:00:59.693 --> 00:01:02.619
conforme sua aplicação for
crescendo, provavelmente

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

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

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

00:01:11.815 --> 00:01:14.250
Não só a gente não está
conseguindo reaproveitar

00:01:14.250 --> 00:01:16.698
aquele código, porque
ele está espalhado no meio

00:01:16.698 --> 00:01:19.288
da nossa aplicação, como
se a gente precisar trocar

00:01:19.288 --> 00:01:21.642
aquele comportamento
para adicionar ou remover

00:01:21.642 --> 00:01:23.721
alguma característica,
isso vai ser muito

00:01:23.721 --> 00:01:26.108
complicado, porque a gente
vai ter que depender

00:01:26.108 --> 00:01:28.639
de ferramentas de busca
para procurar algum trecho

00:01:28.639 --> 00:01:31.580
de código e então alterá-lo
em todos os lugares.

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

00:01:34.288 --> 00:01:37.114
lugares 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.524
Com elas, a gente consegue
criar blocos de código

00:01:45.524 --> 00:01:48.393
parametrizáveis e executar
uma lógica específica

00:01:48.393 --> 00:01:51.783
quantas vezes a gente quiser.
Funções existem basicamente

00:01:51.783 --> 00:01:54.541
todas as linguagens,
de uma forma ou de outra.

00:01:54.541 --> 00:01:57.445
E a característica principal
delas é isolar bloco

00:01:57.445 --> 00:02:00.128
de código para reaproveitamento.
Sendo assim,

00:02:00.128 --> 00:02:03.038
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.150
basta alterar dentro
daquela função

00:02:10.150 --> 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:16.758
legal. Agora que você
entendeu a motivação e,

00:02:16.758 --> 00:02:19.270
mais ou menos, a ideia
por trás das funções,

00:02:19.270 --> 00:02:21.524
vamos ver, na prática, 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.104
Aqui no VS Code, eu já
tenho meu arquivo main.

00:02:25.104 --> 00:02:28.010
py criado. 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.702
Cada linguagem de programação
tem a sua forma

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

00:02:34.848 --> 00:02:36.907
Eu vou começar, então,
aqui colocando o nome

00:02:36.907 --> 00:02:39.345
da minha função, 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:49.758
Pronto.
A partir de agora, eu estou livre

00:02:49.758 --> 00:02:52.348
para desenvolver
o corpo da minha função.

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

00:02:55.431 --> 00:02:58.895
essa função for invocada.
No nosso exemplo, a gente vai

00:02:58.895 --> 00:03:02.078
colocar apenas um print,
escrevendo alguma mensagem

00:03:02.078 --> 00:03:06.450
simples, como, por exemplo,
olá, aluno. 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:15.302
Veja só. Aqui no terminal,
eu vou escrever python.

00:03:15.302 --> 00:03:19.530
exe, ponto barra e o
nome do meu arquivo.

00:03:19.530 --> 00:03:23.614
Ponto barra, main.py. E se eu der
um enter, repara que a aplicação

00:03:23.614 --> 00:03:27.750
até executou, mas não aconteceu
nada de muito interessante.

00:03:27.750 --> 00:03:30.142
Isso foi, basicamente,
porque eu declarei a minha

00:03:30.142 --> 00:03:32.790
função, 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:38.100
Eu consigo escrever código
lá dentro, mas ele só

00:03:38.100 --> 00:03:40.342
é executado, de fato,
quando eu invoco

00:03:40.342 --> 00:03:43.235
essa função.
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:48.664
E para fazer isso,
basta eu executar o nome

00:03:48.664 --> 00:03:51.430
dessa função 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:05.416
E bacana, a nossa função está
funcionando, mas ela ainda

00:04:05.416 --> 00:04:08.290
não tem muita funcionalidade
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:17.115
Ou seja, a gente deve,
dependendo do cenário, conseguir

00:04:17.115 --> 00:04:21.265
manipular o comportamento dela
baseado em informações externas.

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

00:04:25.101 --> 00:04:28.770
consegue definir uma lista
de parâmetros que essa função recebe,

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

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

00:04:32.846 --> 00:04:34.584
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.606
para que a gente informe
o nome que a gente

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

00:04:51.750 --> 00:04:53.385
Entendeu? 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.287
Mas caso eu queira deixar
mais claro para algum

00:05:11.287 --> 00:05:13.290
desenvolvedor que pegar
o nosso código,

00:05:13.290 --> 00:05:15.240
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.824
Mas eu estou informando
para ele que o comportamento

00:05:32.824 --> 00:05:34.590
esperado é 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.216
Agora que dentro
do contexto da minha função

00:05:38.216 --> 00:05:40.730
eu tenho essa variável,
eu posso usar ela.

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

00:05:42.862 --> 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.887
E para isso, eu vou
colocar aqui na frente

00:05:49.887 --> 00:05:52.010
do sinal
de mais a variável nome.

00:05:52.010 --> 00:05:53.745
E vamos ver o que acontece
se eu executar

00:05:53.745 --> 00:05:55.770
o meu código do jeito
que ele está.

00:05:55.770 --> 00:05:58.965
Pronto! A gente agora tem
um erro, porque eu defini

00:05:58.965 --> 00:06:02.080
um parâmetro
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
E a ordem com que eu passar
eles vai ser a ordem

00:06:07.235 --> 00:06:11.280
com que o Python vai alocá-los
dentro das variáveis. 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:21.402
dentro da invocação
da minha função, a primeira

00:06:21.402 --> 00:06:24.490
variável que é o nome.
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.548
Ou seja, a gente
consegue controlar

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

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

00:06:53.603 --> 00:06:55.860
eu quiser, 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:03.017
Só que dessa vez,
colocando aluna, e aqui

00:07:03.017 --> 00:07:06.670
embaixo, talvez você esteja
sentindo falta disso.

00:07:06.670 --> 00:07:09.257
Então, mundo, se
eu limpar o meu terminal

00:07:09.257 --> 00:07:11.710
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.526
sendo que cada
uma delas reaproveitou

00:07:16.526 --> 00:07:18.740
o código que a gente
definiu na função,

00:07:18.740 --> 00:07:19.784
mas foi
parametrizado

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

00:07:22.290 --> 00:07:25.029
Incrível, né?
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:38.872
Tenta adicionar um outro
parâmetro, um outro tipo,

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

00:07:41.770 --> 00:07:43.920
Experimenta.
Ganha afinidade com essa sintaxe

00:07:43.920 --> 00:07:45.651
aqui e vamos ver
até onde você chega.

00:07:45.651 --> 00:07:46.651
E aí.