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

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

0:00:13.074,0:00:14.694
Então, nessa brincadeira[br]de reaproveitar

0:00:14.694,0:00:15.474
o que já está feito,

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

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

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

0:00:23.884,0:00:25.494
e construir a nossa primeira.

0:00:25.494,0:00:27.024
Como a gente já comentou,

0:00:27.024,0:00:30.174
a gente consegue reaproveitar[br]bastante coisa no desenvolvimento

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

0:00:32.034,0:00:32.774
Se a gente quisesse,

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

0:00:35.384,0:00:37.864
mas tem alguns problemas[br]nessa abordagem.

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

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

0:00:42.394,0:00:43.354
Dentro dessa mensagem,

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

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

0:00:49.494,0:00:50.844
alguma coisa desse tipo.

0:00:50.844,0:00:53.772
Pronto, esse seu código[br]vai funcionar

0:00:53.772,0:00:57.264
mas felizmente ou, infelizmente,[br]mais para frente no seu código,

0:00:57.264,0:01:00.224
você vai ter que repetir[br]aquele mesmo comportamento.

0:01:00.224,0:01:02.414
E conforme sua aplicação[br]for crescendo,

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

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

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

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

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

0:01:17.504,0:01:19.994
como se a gente precisar[br]trocar aquele comportamento

0:01:19.994,0:01:22.734
para adicionar ou remover[br]alguma característica,

0:01:22.734,0:01:24.454
isso vai ser muito complicado,

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

0:01:26.904,0:01:28.944
para procurar algum[br]trecho de código

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

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

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

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

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

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

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

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

0:01:53.284,0:01:54.834
de uma forma ou de outra.

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

0:01:58.524,0:02:00.414
para reaproveitamento.

0:02:00.414,0:02:03.594
Sendo assim, a gente consegue[br]implementar o que a gente quiser

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

0:02:06.024,0:02:08.004
Se a gente precisar alterar[br]um comportamento,

0:02:08.004,0:02:10.204
basta alterar dentro[br]daquela função

0:02:10.204,0:02:12.284
e aonde ela estiver[br]sendo referenciada,

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

0:02:14.254,0:02:15.014
Legal.

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

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

0:02:19.924,0:02:21.574
como que isso funciona no Python.

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

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

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

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

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

0:02:33.468,0:02:35.214
e é assim que a gente faz no Python.

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

0:02:37.554,0:02:39.644
que vai ser exatamente[br]minha_funcao.

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

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

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

0:02:47.624,0:02:48.254
Pronto.

0:02:48.254,0:02:49.014
A partir de agora,

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

0:02:52.074,0:02:54.464
Ou seja, o que eu quero[br]que seja executado

0:02:54.464,0:02:56.474
quando essa função for invocada.

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

0:02:59.374,0:03:02.344
escrevendo alguma mensagem[br]simples, como, por exemplo,

0:03:02.344,0:03:06.344
"Olá, Aluno",[br]e salvar o arquivo.

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

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

0:03:11.714,0:03:12.634
Veja só.

0:03:12.634,0:03:16.788
Aqui no terminal,[br]eu vou escrever "python.exe .\",

0:03:16.788,0:03:19.404
e o nome do meu arquivo.

0:03:19.404,0:03:21.474
.\main.py.

0:03:21.474,0:03:22.534
E se eu der um enter,

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

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

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

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

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

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

0:03:37.944,0:03:39.694
mas ele só é executado,[br]de fato,

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

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

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

0:03:46.114,0:03:46.904
Para fazer isso,

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

0:03:49.564,0:03:51.264
e colocar aqui os parênteses.

0:03:51.264,0:03:53.174
Dessa forma, eu estou[br]pedindo para o python

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

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

0:03:59.434,0:04:02.494
a gente tem a mensagem[br]"Olá, Aluno", sendo exibida.

0:04:02.494,0:04:04.904
E bacana, a nossa função[br]está funcionando,

0:04:04.904,0:04:06.854
mas ela ainda não tem[br]muita funcionalidade

0:04:06.854,0:04:08.164
na nossa aplicação.

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

0:04:10.653,0:04:13.524
é ter a capacidade[br]de ser parametrizada.

0:04:13.524,0:04:16.614
Ou seja, a gente deve,[br]dependendo do cenário,

0:04:16.614,0:04:19.054
conseguir manipular[br]o comportamento dela

0:04:19.054,0:04:21.134
baseado em informações externas.

0:04:21.134,0:04:24.034
E isso a gente faz justamente através[br]de parâmetros.

0:04:24.034,0:04:27.094
No Python, a gente consegue definir[br]uma lista de parâmetros

0:04:27.094,0:04:28.624
que essa função recebe,

0:04:28.624,0:04:31.134
semelhante à própria[br]funcionativa print.

0:04:31.134,0:04:32.484
Se a gente quiser[br]executar ela,

0:04:32.484,0:04:34.384
a gente tem que mandar[br]um string, ou seja,

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

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

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

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

0:04:47.714,0:04:49.624
para que a gente informe[br]o nome que a gente

0:04:49.624,0:04:51.524
quer que esteja[br]dentro da mensagem.

0:04:51.524,0:04:52.296
Entendeu?

0:04:52.296,0:04:53.164
Então, vamos lá.

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

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

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

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

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

0:05:09.054,0:05:11.884
Mas caso eu queira deixar[br]mais claro para algum desenvolvedor

0:05:11.884,0:05:14.864
que pegar o nosso código,[br]eu posso colocar aqui do lado,

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

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

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

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

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

0:05:30.404,0:05:33.034
Mas eu estou informando para ele[br]que o comportamento esperado

0:05:33.034,0:05:34.434
é que ele mande um texto.

0:05:34.434,0:05:35.064
Tá bom?

0:05:35.064,0:05:35.694
Então vamos lá.

0:05:35.694,0:05:39.264
Agora que dentro do contexto[br]da minha função eu tenho essa variável,

0:05:39.264,0:05:40.659
eu posso usar ela.

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

0:05:42.694,0:05:45.234
e remover a palavra aluno[br]da minha mensagem,

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

0:05:47.604,0:05:50.674
E para isso, eu vou colocar[br]aqui na frente do sinal de mais

0:05:50.674,0:05:51.904
a variável nome.

0:05:51.904,0:05:54.174
E vamos ver o que acontece[br]se eu executar o meu código

0:05:54.174,0:05:55.634
do jeito que ele está.

0:05:55.634,0:05:56.447
Pronto.

0:05:56.447,0:05:59.664
A gente agora tem um erro,[br]porque eu defini um parâmetro

0:05:59.664,0:06:01.964
e ele é um parâmetro posicional.

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

0:06:04.694,0:06:07.064
A ordem com que eu passar[br]eles vai ser a ordem

0:06:07.064,0:06:10.124
com que o Python vai alocá-los[br]dentro das variáveis.

0:06:10.124,0:06:11.174
Vamos lá.

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

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

0:06:18.254,0:06:20.584
dentro da invocação[br]da minha função,

0:06:20.584,0:06:22.154
a primeira variável[br]que é o nome.

0:06:22.154,0:06:24.364
Por exemplo, "Aluno".

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

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

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

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

0:06:35.524,0:06:37.154
Então eu vou remover a idade.

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

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

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

0:06:46.464,0:06:49.274
Ou seja, a gente consegue[br]controlar o comportamento

0:06:49.274,0:06:51.304
daquela função do lado de fora.

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

0:06:54.254,0:06:55.774
eu posso sem problema nenhum.

0:06:55.774,0:06:57.824
Imagina, por exemplo,[br]que aqui embaixo

0:06:57.824,0:06:59.914
eu vou querer executar[br]ela mais duas vezes.

0:06:59.914,0:07:03.624
Só que dessa vez,[br]colocando "Aluna",

0:07:03.624,0:07:04.704
e aqui embaixo,

0:07:04.704,0:07:06.524
talvez você esteja[br]sentindo falta disso.

0:07:06.524,0:07:07.914
Então, "Mundo".

0:07:07.914,0:07:11.624
Se eu limpar o meu terminal[br]e executar novamente a aplicação,

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

0:07:14.534,0:07:17.244
sendo que cada uma delas[br]reaproveitou o código

0:07:17.244,0:07:19.884
que a gente definiu na função,[br]mas foi parametrizado

0:07:19.884,0:07:21.934
para que o comportamento[br]fosse diferente.

0:07:21.934,0:07:23.104
Incrível, né?

0:07:23.104,0:07:25.044
A gente construiu uma função simples,

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

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

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

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

0:07:36.144,0:07:38.504
Tenta adicionar um outro parâmetro,[br]um outro tipo,

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

0:07:41.384,0:07:42.224
Experimenta.

0:07:42.224,0:07:45.834
Ganhe afinidade com essa sintaxe aqui[br]e vamos ver até onde você chega.