0:00:07.990,0:00:10.580
Quando a gente está implementando[br]alguma coisa nova,

0:00:10.580,0:00:13.170
a gente nunca constrói [br]tudo do zero.

0:00:13.170,0:00:15.230
Então, nessa brincadeira [br]de reaproveitar

0:00:15.230,0:00:16.442
o que já está feito,

0:00:16.442,0:00:18.232
a gente começa a conversar sobre[br]função nativa para cá e para lá,

0:00:18.232,0:00:22.352
e agora finalmente chegou[br]o momento da gente entender

0:00:22.352,0:00:23.503
o que são funções,[br]para que servem

0:00:23.503,0:00:25.386
e construir a nossa primeira.

0:00:25.386,0:00:26.328
Como a gente já comentou,

0:00:26.328,0:00:30.080
a gente consegue reaproveitar [br]bastante coisa no desenvolvimento

0:00:30.080,0:00:31.988
e tem vários motivos[br]para fazer isso.

0:00:31.988,0:00:34.914
Se a gente quisesse,

0:00:34.914,0:00:36.377
a gente até poderia fazer [br]isso tudo do zero,

0:00:36.377,0:00:37.840
mas tem alguns problemas [br]nessa abordagem.

0:00:37.840,0:00:39.005
Imagina que dentro [br]da sua aplicação,

0:00:39.005,0:00:42.361
você tem que exibir uma mensagem[br]para algum usuário.

0:00:42.361,0:00:43.770
Dentro dessa mensagem,

0:00:43.770,0:00:45.889
você provavelmente [br]vai ter o nome do usuário

0:00:45.889,0:00:48.502
e alguns elementos extras, [br]como um prefixo ou sufixo,

0:00:48.502,0:00:49.809
alguma coisa desse tipo.

0:00:49.809,0:00:51.909
Pronto, esse seu código [br]vai funcionar mais,

0:00:51.909,0:00:54.391
felizmente ou, infelizmente, [br]mais para frente no seu código,

0:00:54.391,0:00:57.042
você vai ter que repetir [br]aquele mesmo comportamento.

0:00:57.042,0:00:59.830
E conforme sua aplicação [br]for crescendo,

0:00:59.830,0:01:05.670
provavelmente em outros lugares [br]você vai ter que fazer isso também.

0:01:05.670,0:01:07.025
E não só nesse arquivo,[br]mas em vários outros arquivos.

0:01:07.025,0:01:11.815
E agora você já está começando[br]a enxergar qual que é o problema.

0:01:11.815,0:01:14.256
Não só a gente não está conseguindo [br]reaproveitar aquele código,

0:01:14.256,0:01:16.772
porque ele está espalhado [br]no meio da nossa aplicação,

0:01:16.772,0:01:19.207
como se a gente precisar [br]trocar aquele comportamento

0:01:19.207,0:01:21.464
para adicionar ou remover[br]alguma característica,

0:01:21.464,0:01:23.786
isso vai ser muito complicado,

0:01:23.786,0:01:26.212
porque a gente vai ter que depender[br]de ferramentas de busca

0:01:26.212,0:01:28.896
para procurar algum [br]trecho de código

0:01:28.896,0:01:31.580
e então alterá-lo[br]em todos os lugares.

0:01:31.580,0:01:34.347
É muito fácil a gente acabar [br]esquecendo um ou dois lugares

0:01:34.347,0:01:37.114
e, com isso, injetar[br]bugs no nosso programa.

0:01:37.114,0:01:39.908
Para resolver esse problema,[br]a gente tem as funções,

0:01:39.908,0:01:42.608
que é a porta de entrada[br]para o tema de abstração.

0:01:42.608,0:01:45.500
Com elas, a gente consegue criar blocos [br]de código parametrizáveis

0:01:45.500,0:01:48.641
e executar uma lógica específica[br]quantas vezes a gente quiser.

0:01:48.641,0:01:51.591
Funções existem basicamente[br]todas as linguagens,

0:01:51.591,0:01:54.541
de uma forma ou de outra.

0:01:54.541,0:01:57.334
E a característica principal[br]delas é isolar bloco de código

0:01:57.334,0:01:58.731
para reaproveitamento.

0:01:58.731,0:02:03.038
Sendo assim, a gente consegue [br]implementar o que a gente quiser

0:02:03.038,0:02:06.150
e dar manutenção [br]em um só lugar do nosso código.

0:02:06.150,0:02:08.387
Se a gente precisar alterar [br]um comportamento,

0:02:08.387,0:02:10.232
basta alterar dentro [br]daquela função

0:02:10.232,0:02:12.078
e aonde ela estiver[br]sendo referenciada,

0:02:12.078,0:02:14.550
o comportamento [br]vai ser atualizado também.

0:02:14.550,0:02:15.654
Legal.

0:02:15.654,0:02:17.462
Agora que você entendeu a motivação [br]e, mais ou menos,

0:02:17.462,0:02:19.493
a ideia por trás das funções,[br]vamos ver, na prática,

0:02:19.493,0:02:21.524
como que isso funciona no Python.

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

0:02:23.090,0:02:25.550
Aqui no VS Code, eu já tenho [br]o meu arquivo main.py criado.

0:02:25.550,0:02:28.010
Então, vamos começar[br]definindo a nossa função.

0:02:28.010,0:02:30.520
E, para isso, eu vou usar[br]a palavra reservada def.

0:02:30.520,0:02:32.684
Cada linguagem de programação[br]tem a sua forma de fazer

0:02:32.684,0:02:34.848
e é assim que a gente faz no Python.

0:02:34.848,0:02:37.096
Eu vou começar, então, aqui colocando [br]o nome da minha função,

0:02:37.096,0:02:39.345
que vai ser exatamente [br]minha função.

0:02:39.345,0:02:42.360
A gente pode mudar isso [br]no futuro sem problema nenhum.

0:02:42.360,0:02:45.109
E, para que o Python entenda,[br]de fato, que isso é uma função,

0:02:45.109,0:02:47.371
eu vou colocar aqui[br]os parênteses e os dois pontos.

0:02:47.371,0:02:48.564
Pronto.

0:02:48.564,0:02:50.456
A partir de agora,

0:02:50.456,0:02:52.348
eu estou livre para desenvolver [br]o corpo da minha função.

0:02:52.348,0:02:53.889
Ou seja, o que eu quero[br]que seja executado

0:02:53.889,0:02:56.392
quando essa função for invocada.

0:02:56.392,0:02:59.235
No nosso exemplo, a gente vai[br]colocar apenas um print,

0:02:59.235,0:03:02.842
escrevendo alguma mensagem[br]simples, como, por exemplo,

0:03:02.842,0:03:04.646
"olá, aluno".

0:03:04.646,0:03:06.450
E salvar o arquivo.

0:03:06.450,0:03:09.563
Nesse momento, a gente já pode[br]executar a nossa aplicação

0:03:09.563,0:03:11.860
usando o python.exe[br]e o nome do arquivo.

0:03:11.860,0:03:13.581
Veja só.

0:03:13.581,0:03:16.555
Aqui no terminal,[br]eu vou escrever python.exe,

0:03:16.555,0:03:19.530
ponto barra e o nome do meu arquivo.

0:03:19.530,0:03:21.572
Ponto barra, main.py.

0:03:21.572,0:03:24.661
E se eu der um enter,

0:03:24.661,0:03:26.205
repara que a aplicação [br]até executou,

0:03:26.205,0:03:27.750
mas não aconteceu nada [br]de muito interessante.

0:03:27.750,0:03:30.270
Isso foi, basicamente, [br]porque eu declarei a minha função,

0:03:30.270,0:03:32.790
mas eu não invoquei[br]ela em lugar algum.

0:03:32.790,0:03:35.298
Lembra, funções são[br]blocos de abstração.

0:03:35.298,0:03:36.699
Eu consigo escrever [br]código lá dentro,

0:03:36.699,0:03:38.520
mas ele só é executado, [br]de fato,

0:03:38.520,0:03:40.877
quando eu invoco [br]essa função.

0:03:40.877,0:03:43.235
Então, vamos lá,[br]aqui no nosso código.

0:03:43.235,0:03:46.185
E aqui embaixo, eu vou[br]invocar essa função.

0:03:46.185,0:03:47.424
Para fazer isso,

0:03:47.424,0:03:49.427
basta eu executar [br]o nome dessa função

0:03:49.427,0:03:51.430
e colocar aqui os parênteses.

0:03:51.430,0:03:53.438
Dessa forma, eu estou[br]pedindo para o python

0:03:53.438,0:03:56.310
para que ele pegue e execute[br]aquele bloco de código.

0:03:56.310,0:03:59.315
Se eu rodar novamente [br]o meu programa, dessa vez sim,

0:03:59.315,0:04:02.620
a gente tem a mensagem[br]"olá, alunos", sendo exibida.

0:04:02.620,0:04:05.416
E bacana, a nossa função está[br]funcionando, mas ela ainda

0:04:05.416,0:04:08.290
não tem muita funcionalidade[br]na nossa aplicação.

0:04:08.290,0:04:10.943
Porque uma das[br]características de funções

0:04:10.943,0:04:13.670
é ter a capacidade[br]de ser parametrizada.

0:04:13.670,0:04:17.115
Ou seja, a gente deve,[br]dependendo do cenário, conseguir

0:04:17.115,0:04:21.265
manipular o comportamento dela[br]baseado em informações externas.

0:04:21.265,0:04:25.101
E isso a gente faz justamente através[br]de parâmetros. No Python, a gente

0:04:25.101,0:04:28.770
consegue definir uma lista[br]de parâmetros que essa função recebe,

0:04:28.770,0:04:30.827
semelhante à própria[br]funcionativa print.

0:04:30.827,0:04:32.846
Se a gente quiser[br]executar ela, a gente

0:04:32.846,0:04:34.584
tem que mandar[br]um string, ou seja,

0:04:34.584,0:04:37.155
um texto que vai ser[br]exibido no terminal.

0:04:37.155,0:04:40.295
É assim que a gente controla[br]o comportamento da função print,

0:04:40.295,0:04:44.215
parametrizando para ela a mensagem[br]que a gente quer que seja exibida.

0:04:44.215,0:04:47.426
No nosso caso, o que a gente vai[br]fazer é adicionar um parâmetro

0:04:47.426,0:04:49.606
para que a gente informe[br]o nome que a gente

0:04:49.606,0:04:51.750
quer que esteja[br]dentro da mensagem.

0:04:51.750,0:04:53.385
Entendeu? Então, vamos lá.

0:04:53.385,0:04:56.450
Aqui no nosso código, então,[br]eu vou começar entre os parênteses,

0:04:56.450,0:04:59.490
colocando o meu parâmetro,[br]que eu vou chamar de nome.

0:04:59.490,0:05:01.873
E no Python, a gente[br]tem a tipagem dinâmica.

0:05:01.873,0:05:05.435
Isso significa que eu posso[br]deixar o meu código dessa forma,

0:05:05.435,0:05:09.190
e em tempo de execução, o Python[br]vai saber o tipo dessa variável.

0:05:09.190,0:05:11.287
Mas caso eu queira deixar[br]mais claro para algum

0:05:11.287,0:05:13.290
desenvolvedor que pegar[br]o nosso código,

0:05:13.290,0:05:15.240
eu posso colocar[br]aqui do lado,

0:05:15.240,0:05:18.550
na frente dos dois[br]pontos, o tipo str.

0:05:18.550,0:05:22.300
Lembra, isso não vai mudar[br]na prática nada dentro da linguagem,

0:05:22.300,0:05:24.300
mas vai fazer com que alguém[br]que pegue meu código

0:05:24.300,0:05:26.850
entenda que eu estou esperando[br]que ele mande um string.

0:05:26.850,0:05:30.540
Se ele mandar um número, o Python[br]não vai reclamar nesse momento.

0:05:30.540,0:05:32.824
Mas eu estou informando[br]para ele que o comportamento

0:05:32.824,0:05:34.590
esperado é que ele mande[br]um texto.

0:05:34.590,0:05:35.950
Tá bom? Então vamos lá.

0:05:35.950,0:05:38.216
Agora que dentro[br]do contexto da minha função

0:05:38.216,0:05:40.730
eu tenho essa variável,[br]eu posso usar ela.

0:05:40.730,0:05:42.862
Então eu vou basicamente[br]copiar ela aqui

0:05:42.862,0:05:45.450
e remover a palavra[br]aluno da minha mensagem,

0:05:45.450,0:05:47.720
porque agora eu vou fazer[br]uma concatenação simples.

0:05:47.720,0:05:49.887
E para isso, eu vou[br]colocar aqui na frente

0:05:49.887,0:05:52.010
do sinal[br]de mais a variável nome.

0:05:52.010,0:05:53.745
E vamos ver o que acontece[br]se eu executar

0:05:53.745,0:05:55.770
o meu código do jeito[br]que ele está.

0:05:55.770,0:05:58.965
Pronto! A gente agora tem[br]um erro, porque eu defini

0:05:58.965,0:06:02.080
um parâmetro[br]e ele é um parâmetro posicional.

0:06:02.080,0:06:04.536
Ou seja, eu posso definir[br]vários parâmetros.

0:06:04.536,0:06:07.235
E a ordem com que eu passar[br]eles vai ser a ordem

0:06:07.235,0:06:11.280
com que o Python vai alocá-los[br]dentro das variáveis. Vamos lá.

0:06:11.280,0:06:14.420
Isso significa que se eu tivesse[br]uma outra variável aqui,

0:06:14.420,0:06:18.330
por exemplo, idade, eu teria[br]que passar aqui embaixo,

0:06:18.330,0:06:21.402
dentro da invocação[br]da minha função, a primeira

0:06:21.402,0:06:24.490
variável que é o nome.[br]Por exemplo, aluno.

0:06:24.490,0:06:27.490
E se eu quiser passar idade,[br]eu coloco aqui na frente.

0:06:27.490,0:06:29.873
Repara que a própria IDE já[br]vai dando dicas para a gente

0:06:29.873,0:06:32.575
de como que a gente está[br]esperando receber os valores.

0:06:32.575,0:06:35.402
Mas no nosso cenário, a gente[br]só vai ter um parâmetro.

0:06:35.402,0:06:37.280
Então eu vou[br]remover a idade.

0:06:37.280,0:06:40.510
E se a gente executa novamente[br]o nosso código, agora sim.

0:06:40.510,0:06:43.940
A gente tem a mesma mensagem[br]de antes, mas um pouco diferente.

0:06:43.940,0:06:46.570
Porque essa mensagem agora,[br]ela está parametrizável.

0:06:46.570,0:06:48.548
Ou seja, a gente[br]consegue controlar

0:06:48.548,0:06:51.410
o comportamento daquela[br]função do lado de fora.

0:06:51.410,0:06:53.603
E se eu quiser usar[br]essa função quantas vezes

0:06:53.603,0:06:55.860
eu quiser, eu posso[br]sem problema nenhum.

0:06:55.860,0:06:57.860
Então, imagina, por exemplo,[br]que aqui embaixo

0:06:57.860,0:07:00.040
eu vou querer executar[br]ela mais duas vezes.

0:07:00.040,0:07:03.017
Só que dessa vez,[br]colocando aluna, e aqui

0:07:03.017,0:07:06.670
embaixo, talvez você esteja[br]sentindo falta disso.

0:07:06.670,0:07:09.257
Então, mundo, se[br]eu limpar o meu terminal

0:07:09.257,0:07:11.710
e executar novamente[br]a aplicação,

0:07:11.710,0:07:14.730
a gente vê que a gente tem[br]as três exibições daquela função,

0:07:14.730,0:07:16.526
sendo que cada[br]uma delas reaproveitou

0:07:16.526,0:07:18.740
o código que a gente[br]definiu na função,

0:07:18.740,0:07:19.784
mas foi[br]parametrizado

0:07:19.784,0:07:22.290
para que o comportamento[br]fosse diferente.

0:07:22.290,0:07:25.029
Incrível, né?[br]A gente construiu uma função simples,

0:07:25.029,0:07:27.870
mas as funções estão[br]por todo lugar na linguagem.

0:07:27.870,0:07:30.348
Sejam funções nativas[br]ou funções de pacote que a gente

0:07:30.348,0:07:32.850
vai uma hora ou outra[br]até que acabar usando.

0:07:32.850,0:07:36.290
Dá uma explorada nesse código aqui[br]e tenta melhorar ele um pouco.

0:07:36.290,0:07:38.872
Tenta adicionar um outro[br]parâmetro, um outro tipo,

0:07:38.872,0:07:41.770
faz condicionais lá[br]dentro, loops, quem sabe.

0:07:41.770,0:07:43.920
Experimenta.[br]Ganha afinidade com essa sintaxe

0:07:43.920,0:07:45.651
aqui e vamos ver[br]até onde você chega.

0:07:45.651,0:07:46.651
E aí.