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

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

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

0:00:15.230,0:00:17.654
o que já está feito,[br]a gente começa a conversar

0:00:17.654,0:00:20.022
sobre função nativa[br]para cá e para lá, e agora

0:00:20.022,0:00:22.352
finalmente chegou[br]o momento da gente entender

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

0:00:24.655,0:00:27.270
a nossa primeira.[br]Como a gente já comentou, a gente

0:00:27.270,0:00:30.080
consegue reaproveitar bastante[br]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.826
Se a gente quisesse, a gente[br]até poderia fazer isso

0:00:34.826,0:00:37.840
tudo do zero, mas tem alguns[br]problemas nessa abordagem.

0:00:37.840,0:00:40.170
Imagina que dentro da sua[br]aplicação, você tem

0:00:40.170,0:00:42.361
que exibir uma mensagem[br]para algum usuário.

0:00:42.361,0:00:45.179
Dentro dessa mensagem,[br]você provavelmente vai ter

0:00:45.179,0:00:48.009
o nome do usuário e alguns[br]elementos extras, como

0:00:48.009,0:00:51.116
um prefixo ou sufixo, alguma[br]coisa desse tipo. Pronto,

0:00:51.116,0:00:54.009
esse seu código vai funcionar[br]mais, felizmente ou,

0:00:54.009,0:00:56.873
infelizmente, mais para frente[br]no seu código, você

0:00:56.873,0:00:59.693
vai ter que repetir aquele[br]mesmo comportamento. E

0:00:59.693,0:01:02.619
conforme sua aplicação for[br]crescendo, provavelmente

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

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

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

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

0:01:14.250,0:01:16.698
aquele código, porque[br]ele está espalhado no meio

0:01:16.698,0:01:19.288
da nossa aplicação, como[br]se a gente precisar trocar

0:01:19.288,0:01:21.642
aquele comportamento[br]para adicionar ou remover

0:01:21.642,0:01:23.721
alguma característica,[br]isso vai ser muito

0:01:23.721,0:01:26.108
complicado, porque a gente[br]vai ter que depender

0:01:26.108,0:01:28.639
de ferramentas de busca[br]para procurar algum trecho

0:01:28.639,0:01:31.580
de código e então alterá-lo[br]em todos os lugares.

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

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

0:01:45.524,0:01:48.393
parametrizáveis e executar[br]uma lógica específica

0:01:48.393,0:01:51.783
quantas vezes a gente quiser.[br]Funções existem basicamente

0:01:51.783,0:01:54.541
todas as linguagens,[br]de uma forma ou de outra.

0:01:54.541,0:01:57.445
E a característica principal[br]delas é isolar bloco

0:01:57.445,0:02:00.128
de código para reaproveitamento.[br]Sendo assim,

0:02:00.128,0:02:03.038
a gente consegue implementar[br]o que a gente quiser

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

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

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

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

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

0:02:14.550,0:02:16.758
legal. Agora que você[br]entendeu a motivação e,

0:02:16.758,0:02:19.270
mais ou menos, a ideia[br]por trás das funções,

0:02:19.270,0:02:21.524
vamos ver, na prática, como[br]que isso funciona no Python.

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

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

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

0:02:32.702,0:02:34.848
de fazer e é assim[br]que a gente faz no Python.

0:02:34.848,0:02:36.907
Eu vou começar, então,[br]aqui colocando o nome

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

0:02:39.345,0:02:42.360
A gente pode mudar isso no[br]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:49.758
Pronto.[br]A partir de agora, eu estou livre

0:02:49.758,0:02:52.348
para desenvolver[br]o corpo da minha função.

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

0:02:55.431,0:02:58.895
essa função for invocada.[br]No nosso exemplo, a gente vai

0:02:58.895,0:03:02.078
colocar apenas um print,[br]escrevendo alguma mensagem

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

0:03:15.302,0:03:19.530
exe, ponto barra e o[br]nome do meu arquivo.

0:03:19.530,0:03:23.614
Ponto barra, main.py. E se eu der[br]um enter, repara que a aplicação

0:03:23.614,0:03:27.750
até executou, mas não aconteceu[br]nada de muito interessante.

0:03:27.750,0:03:30.142
Isso foi, basicamente,[br]porque eu declarei a minha

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

0:03:38.100,0:03:40.342
é executado, de fato,[br]quando eu invoco

0:03:40.342,0:03:43.235
essa função.[br]Então, vamos lá 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:48.664
E para fazer isso,[br]basta eu executar o nome

0:03:48.664,0:03:51.430
dessa função e colocar[br]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 o meu[br]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í.