1
00:00:07,990 --> 00:00:10,580
Quando a gente está implementando
alguma coisa nova,

2
00:00:10,580 --> 00:00:13,170
a gente nunca constrói 
tudo do zero.

3
00:00:13,170 --> 00:00:15,230
Então, nessa brincadeira 
de reaproveitar

4
00:00:15,230 --> 00:00:16,442
o que já está feito,

5
00:00:16,442 --> 00:00:18,232
a gente começa a conversar sobre
função nativa para cá e para lá,

6
00:00:18,232 --> 00:00:22,352
e agora finalmente chegou
o momento da gente entender

7
00:00:22,352 --> 00:00:23,503
o que são funções,
para que servem

8
00:00:23,503 --> 00:00:25,386
e construir a nossa primeira.

9
00:00:25,386 --> 00:00:26,328
Como a gente já comentou,

10
00:00:26,328 --> 00:00:30,080
a gente consegue reaproveitar 
bastante coisa no desenvolvimento

11
00:00:30,080 --> 00:00:31,988
e tem vários motivos
para fazer isso.

12
00:00:31,988 --> 00:00:34,914
Se a gente quisesse,

13
00:00:34,914 --> 00:00:36,377
a gente até poderia fazer 
isso tudo do zero,

14
00:00:36,377 --> 00:00:37,840
mas tem alguns problemas 
nessa abordagem.

15
00:00:37,840 --> 00:00:39,005
Imagina que dentro 
da sua aplicação,

16
00:00:39,005 --> 00:00:42,361
você tem que exibir uma mensagem
para algum usuário.

17
00:00:42,361 --> 00:00:43,770
Dentro dessa mensagem,

18
00:00:43,770 --> 00:00:45,889
você provavelmente 
vai ter o nome do usuário

19
00:00:45,889 --> 00:00:48,502
e alguns elementos extras, 
como um prefixo ou sufixo,

20
00:00:48,502 --> 00:00:49,809
alguma coisa desse tipo.

21
00:00:49,809 --> 00:00:51,909
Pronto, esse seu código 
vai funcionar mais,

22
00:00:51,909 --> 00:00:54,391
felizmente ou, infelizmente, 
mais para frente no seu código,

23
00:00:54,391 --> 00:00:57,042
você vai ter que repetir 
aquele mesmo comportamento.

24
00:00:57,042 --> 00:00:59,830
E conforme sua aplicação 
for crescendo,

25
00:00:59,830 --> 00:01:05,670
provavelmente em outros lugares 
você vai ter que fazer isso também.

26
00:01:05,670 --> 00:01:07,025
E não só nesse arquivo,
mas em vários outros arquivos.

27
00:01:07,025 --> 00:01:11,815
E agora você já está começando
a enxergar qual que é o problema.

28
00:01:11,815 --> 00:01:14,256
Não só a gente não está conseguindo 
reaproveitar aquele código,

29
00:01:14,256 --> 00:01:16,772
porque ele está espalhado 
no meio da nossa aplicação,

30
00:01:16,772 --> 00:01:19,207
como se a gente precisar 
trocar aquele comportamento

31
00:01:19,207 --> 00:01:21,464
para adicionar ou remover
alguma característica,

32
00:01:21,464 --> 00:01:23,786
isso vai ser muito complicado,

33
00:01:23,786 --> 00:01:26,212
porque a gente vai ter que depender
de ferramentas de busca

34
00:01:26,212 --> 00:01:28,896
para procurar algum 
trecho de código

35
00:01:28,896 --> 00:01:31,580
e então alterá-lo
em todos os lugares.

36
00:01:31,580 --> 00:01:34,347
É muito fácil a gente acabar 
esquecendo um ou dois lugares

37
00:01:34,347 --> 00:01:37,114
e, com isso, injetar
bugs no nosso programa.

38
00:01:37,114 --> 00:01:39,908
Para resolver esse problema,
a gente tem as funções,

39
00:01:39,908 --> 00:01:42,608
que é a porta de entrada
para o tema de abstração.

40
00:01:42,608 --> 00:01:45,500
Com elas, a gente consegue criar blocos 
de código parametrizáveis

41
00:01:45,500 --> 00:01:48,641
e executar uma lógica específica
quantas vezes a gente quiser.

42
00:01:48,641 --> 00:01:51,591
Funções existem basicamente
todas as linguagens,

43
00:01:51,591 --> 00:01:54,541
de uma forma ou de outra.

44
00:01:54,541 --> 00:01:57,334
E a característica principal
delas é isolar bloco de código

45
00:01:57,334 --> 00:01:58,731
para reaproveitamento.

46
00:01:58,731 --> 00:02:03,038
Sendo assim, a gente consegue 
implementar o que a gente quiser

47
00:02:03,038 --> 00:02:06,150
e dar manutenção 
em um só lugar do nosso código.

48
00:02:06,150 --> 00:02:08,387
Se a gente precisar alterar 
um comportamento,

49
00:02:08,387 --> 00:02:10,232
basta alterar dentro 
daquela função

50
00:02:10,232 --> 00:02:12,078
e aonde ela estiver
sendo referenciada,

51
00:02:12,078 --> 00:02:14,550
o comportamento 
vai ser atualizado também.

52
00:02:14,550 --> 00:02:15,654
Legal.

53
00:02:15,654 --> 00:02:17,462
Agora que você entendeu a motivação 
e, mais ou menos,

54
00:02:17,462 --> 00:02:19,493
a ideia por trás das funções,
vamos ver, na prática,

55
00:02:19,493 --> 00:02:21,524
como que isso funciona no Python.

56
00:02:21,524 --> 00:02:23,090
Então, vamos lá para o código.

57
00:02:23,090 --> 00:02:25,550
Aqui no VS Code, eu já tenho 
o meu arquivo main.py criado.

58
00:02:25,550 --> 00:02:28,010
Então, vamos começar
definindo a nossa função.

59
00:02:28,010 --> 00:02:30,520
E, para isso, eu vou usar
a palavra reservada def.

60
00:02:30,520 --> 00:02:32,684
Cada linguagem de programação
tem a sua forma de fazer

61
00:02:32,684 --> 00:02:34,848
e é assim que a gente faz no Python.

62
00:02:34,848 --> 00:02:37,096
Eu vou começar, então, aqui colocando 
o nome da minha função,

63
00:02:37,096 --> 00:02:39,345
que vai ser exatamente 
minha função.

64
00:02:39,345 --> 00:02:42,360
A gente pode mudar isso 
no futuro sem problema nenhum.

65
00:02:42,360 --> 00:02:45,109
E, para que o Python entenda,
de fato, que isso é uma função,

66
00:02:45,109 --> 00:02:47,371
eu vou colocar aqui
os parênteses e os dois pontos.

67
00:02:47,371 --> 00:02:48,564
Pronto.

68
00:02:48,564 --> 00:02:50,456
A partir de agora,

69
00:02:50,456 --> 00:02:52,348
eu estou livre para desenvolver 
o corpo da minha função.

70
00:02:52,348 --> 00:02:53,889
Ou seja, o que eu quero
que seja executado

71
00:02:53,889 --> 00:02:56,392
quando essa função for invocada.

72
00:02:56,392 --> 00:02:59,235
No nosso exemplo, a gente vai
colocar apenas um print,

73
00:02:59,235 --> 00:03:02,842
escrevendo alguma mensagem
simples, como, por exemplo,

74
00:03:02,842 --> 00:03:04,646
"olá, aluno".

75
00:03:04,646 --> 00:03:06,450
E salvar o arquivo.

76
00:03:06,450 --> 00:03:09,563
Nesse momento, a gente já pode
executar a nossa aplicação

77
00:03:09,563 --> 00:03:11,860
usando o python.exe
e o nome do arquivo.

78
00:03:11,860 --> 00:03:13,581
Veja só.

79
00:03:13,581 --> 00:03:16,555
Aqui no terminal,
eu vou escrever python.exe,

80
00:03:16,555 --> 00:03:19,530
ponto barra e o nome do meu arquivo.

81
00:03:19,530 --> 00:03:21,572
Ponto barra, main.py.

82
00:03:21,572 --> 00:03:24,661
E se eu der um enter,

83
00:03:24,661 --> 00:03:26,205
repara que a aplicação 
até executou,

84
00:03:26,205 --> 00:03:27,750
mas não aconteceu nada 
de muito interessante.

85
00:03:27,750 --> 00:03:30,270
Isso foi, basicamente, 
porque eu declarei a minha função,

86
00:03:30,270 --> 00:03:32,790
mas eu não invoquei
ela em lugar algum.

87
00:03:32,790 --> 00:03:35,298
Lembra, funções são
blocos de abstração.

88
00:03:35,298 --> 00:03:36,699
Eu consigo escrever 
código lá dentro,

89
00:03:36,699 --> 00:03:38,520
mas ele só é executado, 
de fato,

90
00:03:38,520 --> 00:03:40,877
quando eu invoco 
essa função.

91
00:03:40,877 --> 00:03:43,235
Então, vamos lá,
aqui no nosso código.

92
00:03:43,235 --> 00:03:46,185
E aqui embaixo, eu vou
invocar essa função.

93
00:03:46,185 --> 00:03:47,424
Para fazer isso,

94
00:03:47,424 --> 00:03:49,427
basta eu executar 
o nome dessa função

95
00:03:49,427 --> 00:03:51,430
e colocar aqui os parênteses.

96
00:03:51,430 --> 00:03:53,438
Dessa forma, eu estou
pedindo para o python

97
00:03:53,438 --> 00:03:56,310
para que ele pegue e execute
aquele bloco de código.

98
00:03:56,310 --> 00:03:59,315
Se eu rodar novamente 
o meu programa, dessa vez sim,

99
00:03:59,315 --> 00:04:02,620
a gente tem a mensagem
"olá, alunos", sendo exibida.

100
00:04:02,620 --> 00:04:05,416
E bacana, a nossa função está
funcionando, mas ela ainda

101
00:04:05,416 --> 00:04:08,290
não tem muita funcionalidade
na nossa aplicação.

102
00:04:08,290 --> 00:04:10,943
Porque uma das
características de funções

103
00:04:10,943 --> 00:04:13,670
é ter a capacidade
de ser parametrizada.

104
00:04:13,670 --> 00:04:17,115
Ou seja, a gente deve,
dependendo do cenário, conseguir

105
00:04:17,115 --> 00:04:21,265
manipular o comportamento dela
baseado em informações externas.

106
00:04:21,265 --> 00:04:25,101
E isso a gente faz justamente através
de parâmetros. No Python, a gente

107
00:04:25,101 --> 00:04:28,770
consegue definir uma lista
de parâmetros que essa função recebe,

108
00:04:28,770 --> 00:04:30,827
semelhante à própria
funcionativa print.

109
00:04:30,827 --> 00:04:32,846
Se a gente quiser
executar ela, a gente

110
00:04:32,846 --> 00:04:34,584
tem que mandar
um string, ou seja,

111
00:04:34,584 --> 00:04:37,155
um texto que vai ser
exibido no terminal.

112
00:04:37,155 --> 00:04:40,295
É assim que a gente controla
o comportamento da função print,

113
00:04:40,295 --> 00:04:44,215
parametrizando para ela a mensagem
que a gente quer que seja exibida.

114
00:04:44,215 --> 00:04:47,426
No nosso caso, o que a gente vai
fazer é adicionar um parâmetro

115
00:04:47,426 --> 00:04:49,606
para que a gente informe
o nome que a gente

116
00:04:49,606 --> 00:04:51,750
quer que esteja
dentro da mensagem.

117
00:04:51,750 --> 00:04:53,385
Entendeu? Então, vamos lá.

118
00:04:53,385 --> 00:04:56,450
Aqui no nosso código, então,
eu vou começar entre os parênteses,

119
00:04:56,450 --> 00:04:59,490
colocando o meu parâmetro,
que eu vou chamar de nome.

120
00:04:59,490 --> 00:05:01,873
E no Python, a gente
tem a tipagem dinâmica.

121
00:05:01,873 --> 00:05:05,435
Isso significa que eu posso
deixar o meu código dessa forma,

122
00:05:05,435 --> 00:05:09,190
e em tempo de execução, o Python
vai saber o tipo dessa variável.

123
00:05:09,190 --> 00:05:11,287
Mas caso eu queira deixar
mais claro para algum

124
00:05:11,287 --> 00:05:13,290
desenvolvedor que pegar
o nosso código,

125
00:05:13,290 --> 00:05:15,240
eu posso colocar
aqui do lado,

126
00:05:15,240 --> 00:05:18,550
na frente dos dois
pontos, o tipo str.

127
00:05:18,550 --> 00:05:22,300
Lembra, isso não vai mudar
na prática nada dentro da linguagem,

128
00:05:22,300 --> 00:05:24,300
mas vai fazer com que alguém
que pegue meu código

129
00:05:24,300 --> 00:05:26,850
entenda que eu estou esperando
que ele mande um string.

130
00:05:26,850 --> 00:05:30,540
Se ele mandar um número, o Python
não vai reclamar nesse momento.

131
00:05:30,540 --> 00:05:32,824
Mas eu estou informando
para ele que o comportamento

132
00:05:32,824 --> 00:05:34,590
esperado é que ele mande
um texto.

133
00:05:34,590 --> 00:05:35,950
Tá bom? Então vamos lá.

134
00:05:35,950 --> 00:05:38,216
Agora que dentro
do contexto da minha função

135
00:05:38,216 --> 00:05:40,730
eu tenho essa variável,
eu posso usar ela.

136
00:05:40,730 --> 00:05:42,862
Então eu vou basicamente
copiar ela aqui

137
00:05:42,862 --> 00:05:45,450
e remover a palavra
aluno da minha mensagem,

138
00:05:45,450 --> 00:05:47,720
porque agora eu vou fazer
uma concatenação simples.

139
00:05:47,720 --> 00:05:49,887
E para isso, eu vou
colocar aqui na frente

140
00:05:49,887 --> 00:05:52,010
do sinal
de mais a variável nome.

141
00:05:52,010 --> 00:05:53,745
E vamos ver o que acontece
se eu executar

142
00:05:53,745 --> 00:05:55,770
o meu código do jeito
que ele está.

143
00:05:55,770 --> 00:05:58,965
Pronto! A gente agora tem
um erro, porque eu defini

144
00:05:58,965 --> 00:06:02,080
um parâmetro
e ele é um parâmetro posicional.

145
00:06:02,080 --> 00:06:04,536
Ou seja, eu posso definir
vários parâmetros.

146
00:06:04,536 --> 00:06:07,235
E a ordem com que eu passar
eles vai ser a ordem

147
00:06:07,235 --> 00:06:11,280
com que o Python vai alocá-los
dentro das variáveis. Vamos lá.

148
00:06:11,280 --> 00:06:14,420
Isso significa que se eu tivesse
uma outra variável aqui,

149
00:06:14,420 --> 00:06:18,330
por exemplo, idade, eu teria
que passar aqui embaixo,

150
00:06:18,330 --> 00:06:21,402
dentro da invocação
da minha função, a primeira

151
00:06:21,402 --> 00:06:24,490
variável que é o nome.
Por exemplo, aluno.

152
00:06:24,490 --> 00:06:27,490
E se eu quiser passar idade,
eu coloco aqui na frente.

153
00:06:27,490 --> 00:06:29,873
Repara que a própria IDE já
vai dando dicas para a gente

154
00:06:29,873 --> 00:06:32,575
de como que a gente está
esperando receber os valores.

155
00:06:32,575 --> 00:06:35,402
Mas no nosso cenário, a gente
só vai ter um parâmetro.

156
00:06:35,402 --> 00:06:37,280
Então eu vou
remover a idade.

157
00:06:37,280 --> 00:06:40,510
E se a gente executa novamente
o nosso código, agora sim.

158
00:06:40,510 --> 00:06:43,940
A gente tem a mesma mensagem
de antes, mas um pouco diferente.

159
00:06:43,940 --> 00:06:46,570
Porque essa mensagem agora,
ela está parametrizável.

160
00:06:46,570 --> 00:06:48,548
Ou seja, a gente
consegue controlar

161
00:06:48,548 --> 00:06:51,410
o comportamento daquela
função do lado de fora.

162
00:06:51,410 --> 00:06:53,603
E se eu quiser usar
essa função quantas vezes

163
00:06:53,603 --> 00:06:55,860
eu quiser, eu posso
sem problema nenhum.

164
00:06:55,860 --> 00:06:57,860
Então, imagina, por exemplo,
que aqui embaixo

165
00:06:57,860 --> 00:07:00,040
eu vou querer executar
ela mais duas vezes.

166
00:07:00,040 --> 00:07:03,017
Só que dessa vez,
colocando aluna, e aqui

167
00:07:03,017 --> 00:07:06,670
embaixo, talvez você esteja
sentindo falta disso.

168
00:07:06,670 --> 00:07:09,257
Então, mundo, se
eu limpar o meu terminal

169
00:07:09,257 --> 00:07:11,710
e executar novamente
a aplicação,

170
00:07:11,710 --> 00:07:14,730
a gente vê que a gente tem
as três exibições daquela função,

171
00:07:14,730 --> 00:07:16,526
sendo que cada
uma delas reaproveitou

172
00:07:16,526 --> 00:07:18,740
o código que a gente
definiu na função,

173
00:07:18,740 --> 00:07:19,784
mas foi
parametrizado

174
00:07:19,784 --> 00:07:22,290
para que o comportamento
fosse diferente.

175
00:07:22,290 --> 00:07:25,029
Incrível, né?
A gente construiu uma função simples,

176
00:07:25,029 --> 00:07:27,870
mas as funções estão
por todo lugar na linguagem.

177
00:07:27,870 --> 00:07:30,348
Sejam funções nativas
ou funções de pacote que a gente

178
00:07:30,348 --> 00:07:32,850
vai uma hora ou outra
até que acabar usando.

179
00:07:32,850 --> 00:07:36,290
Dá uma explorada nesse código aqui
e tenta melhorar ele um pouco.

180
00:07:36,290 --> 00:07:38,872
Tenta adicionar um outro
parâmetro, um outro tipo,

181
00:07:38,872 --> 00:07:41,770
faz condicionais lá
dentro, loops, quem sabe.

182
00:07:41,770 --> 00:07:43,920
Experimenta.
Ganha afinidade com essa sintaxe

183
00:07:43,920 --> 00:07:45,651
aqui e vamos ver
até onde você chega.

184
00:07:45,651 --> 00:07:46,651
E aí.