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

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

3
00:00:13,074 --> 00:00:14,694
Então, nessa brincadeira
de reaproveitar

4
00:00:14,694 --> 00:00:15,474
o que já está feito,

5
00:00:15,474 --> 00:00:19,544
a gente começa a conversar sobre
função nativa para cá e para lá,

6
00:00:19,544 --> 00:00:21,914
e agora finalmente chegou
o momento da gente entender

7
00:00:21,914 --> 00:00:23,884
o que são funções,
para que servem

8
00:00:23,884 --> 00:00:25,494
e construir a nossa primeira.

9
00:00:25,494 --> 00:00:27,024
Como a gente já comentou,

10
00:00:27,024 --> 00:00:30,174
a gente consegue reaproveitar
bastante coisa no desenvolvimento

11
00:00:30,174 --> 00:00:32,034
e tem vários motivos
para fazer isso.

12
00:00:32,034 --> 00:00:32,774
Se a gente quisesse,

13
00:00:32,774 --> 00:00:35,384
a gente até poderia fazer
isso tudo do zero,

14
00:00:35,384 --> 00:00:37,864
mas tem alguns problemas
nessa abordagem.

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

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

17
00:00:42,394 --> 00:00:43,354
Dentro dessa mensagem,

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

19
00:00:45,914 --> 00:00:49,494
e alguns elementos extras,
como um prefixo ou sufixo,

20
00:00:49,494 --> 00:00:50,844
alguma coisa desse tipo.

21
00:00:50,844 --> 00:00:53,772
Pronto, esse seu código
vai funcionar

22
00:00:53,772 --> 00:00:57,264
mas felizmente ou, infelizmente,
mais para frente no seu código,

23
00:00:57,264 --> 00:01:00,224
você vai ter que repetir
aquele mesmo comportamento.

24
00:01:00,224 --> 00:01:02,414
E conforme sua aplicação
for crescendo,

25
00:01:02,414 --> 00:01:05,464
provavelmente em outros lugares
você vai ter que fazer isso também.

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

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

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

29
00:01:14,964 --> 00:01:17,504
porque ele está espalhado
no meio da nossa aplicação,

30
00:01:17,504 --> 00:01:19,994
como se a gente precisar
trocar aquele comportamento

31
00:01:19,994 --> 00:01:22,734
para adicionar ou remover
alguma característica,

32
00:01:22,734 --> 00:01:24,454
isso vai ser muito complicado,

33
00:01:24,454 --> 00:01:26,904
porque a gente vai ter que depender
de ferramentas de busca

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

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

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

37
00:01:34,434 --> 00:01:36,714
e, com isso, injetar
bugs no nosso programa.

38
00:01:36,714 --> 00:01:39,674
Para resolver esse problema,
a gente tem as funções,

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

40
00:01:42,864 --> 00:01:46,924
Com elas, a gente consegue criar blocos
de código parametrizáveis

41
00:01:46,924 --> 00:01:50,534
e executar uma lógica específica
quantas vezes a gente quiser.

42
00:01:50,534 --> 00:01:53,284
Funções existem basicamente
todas as linguagens,

43
00:01:53,284 --> 00:01:54,834
de uma forma ou de outra.

44
00:01:54,834 --> 00:01:58,524
E a característica principal
delas é isolar bloco de código

45
00:01:58,524 --> 00:02:00,414
para reaproveitamento.

46
00:02:00,414 --> 00:02:03,594
Sendo assim, a gente consegue
implementar o que a gente quiser

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

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

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

50
00:02:10,204 --> 00:02:12,284
e aonde ela estiver
sendo referenciada,

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

52
00:02:14,254 --> 00:02:15,014
Legal.

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

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

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

56
00:02:21,574 --> 00:02:22,964
Então, vamos lá para o código.

57
00:02:22,964 --> 00:02:25,684
Aqui no VS Code, eu já tenho
o meu arquivo main.py criado.

58
00:02:25,684 --> 00:02:27,824
Então, vamos começar
definindo a nossa função.

59
00:02:27,824 --> 00:02:30,664
E, para isso, eu vou usar
a palavra reservada def.

60
00:02:30,664 --> 00:02:33,468
Cada linguagem de programação
tem a sua forma de fazer

61
00:02:33,468 --> 00:02:35,214
e é assim que a gente faz no Python.

62
00:02:35,214 --> 00:02:37,554
Eu vou começar, então, aqui colocando
o nome da minha função,

63
00:02:37,554 --> 00:02:39,644
que vai ser exatamente
minha_funcao.

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

65
00:02:42,224 --> 00:02:44,784
E, para que o Python entenda,
de fato, que isso é uma função,

66
00:02:44,784 --> 00:02:47,624
eu vou colocar aqui
os parênteses e os dois pontos.

67
00:02:47,624 --> 00:02:48,254
Pronto.

68
00:02:48,254 --> 00:02:49,014
A partir de agora,

69
00:02:49,014 --> 00:02:52,074
eu estou livre para desenvolver
o corpo da minha função.

70
00:02:52,074 --> 00:02:54,464
Ou seja, o que eu quero
que seja executado

71
00:02:54,464 --> 00:02:56,474
quando essa função for invocada.

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

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

74
00:03:02,344 --> 00:03:06,344
"Olá, Aluno",
e salvar o arquivo.

75
00:03:06,344 --> 00:03:09,154
Nesse momento, a gente já pode
executar a nossa aplicação

76
00:03:09,154 --> 00:03:11,714
usando o python.exe
e o nome do arquivo.

77
00:03:11,714 --> 00:03:12,634
Veja só.

78
00:03:12,634 --> 00:03:16,788
Aqui no terminal,
eu vou escrever "python.exe .\",

79
00:03:16,788 --> 00:03:19,404
e o nome do meu arquivo.

80
00:03:19,404 --> 00:03:21,474
.\main.py.

81
00:03:21,474 --> 00:03:22,534
E se eu der um enter,

82
00:03:22,534 --> 00:03:25,124
repara que a aplicação
até executou,

83
00:03:25,124 --> 00:03:27,644
mas não aconteceu nada
de muito interessante.

84
00:03:27,644 --> 00:03:30,384
Isso foi, basicamente,
porque eu declarei a minha função,

85
00:03:30,384 --> 00:03:32,674
mas eu não invoquei
ela em lugar algum.

86
00:03:32,674 --> 00:03:35,704
Lembra, funções são
blocos de abstração.

87
00:03:35,704 --> 00:03:37,944
Eu consigo escrever
código lá dentro,

88
00:03:37,944 --> 00:03:39,694
mas ele só é executado,
de fato,

89
00:03:39,694 --> 00:03:41,294
quando eu invoco
essa função.

90
00:03:41,294 --> 00:03:43,694
Então, vamos lá,
aqui no nosso código.

91
00:03:43,694 --> 00:03:46,114
E aqui embaixo, eu vou
invocar essa função.

92
00:03:46,114 --> 00:03:46,904
Para fazer isso,

93
00:03:46,904 --> 00:03:49,564
basta eu executar
o nome dessa função

94
00:03:49,564 --> 00:03:51,264
e colocar aqui os parênteses.

95
00:03:51,264 --> 00:03:53,174
Dessa forma, eu estou
pedindo para o python

96
00:03:53,174 --> 00:03:56,134
para que ele pegue e execute
aquele bloco de código.

97
00:03:56,134 --> 00:03:59,434
Se eu rodar novamente
o meu programa, dessa vez sim,

98
00:03:59,434 --> 00:04:02,494
a gente tem a mensagem
"Olá, Aluno", sendo exibida.

99
00:04:02,494 --> 00:04:04,904
E bacana, a nossa função
está funcionando,

100
00:04:04,904 --> 00:04:06,854
mas ela ainda não tem
muita funcionalidade

101
00:04:06,854 --> 00:04:08,164
na nossa aplicação.

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

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

104
00:04:13,524 --> 00:04:16,614
Ou seja, a gente deve,
dependendo do cenário,

105
00:04:16,614 --> 00:04:19,054
conseguir manipular
o comportamento dela

106
00:04:19,054 --> 00:04:21,134
baseado em informações externas.

107
00:04:21,134 --> 00:04:24,034
E isso a gente faz justamente através
de parâmetros.

108
00:04:24,034 --> 00:04:27,094
No Python, a gente consegue definir
uma lista de parâmetros

109
00:04:27,094 --> 00:04:28,624
que essa função recebe,

110
00:04:28,624 --> 00:04:31,134
semelhante à própria
funcionativa print.

111
00:04:31,134 --> 00:04:32,484
Se a gente quiser
executar ela,

112
00:04:32,484 --> 00:04:34,384
a gente tem que mandar
um string, ou seja,

113
00:04:34,384 --> 00:04:37,074
um texto que vai ser
exibido no terminal.

114
00:04:37,074 --> 00:04:40,614
É assim que a gente controla
o comportamento da função print,

115
00:04:40,614 --> 00:04:44,104
parametrizando para ela a mensagem
que a gente quer que seja exibida.

116
00:04:44,104 --> 00:04:47,714
No nosso caso, o que a gente
vai fazer é adicionar um parâmetro

117
00:04:47,714 --> 00:04:49,624
para que a gente informe
o nome que a gente

118
00:04:49,624 --> 00:04:51,524
quer que esteja
dentro da mensagem.

119
00:04:51,524 --> 00:04:52,296
Entendeu?

120
00:04:52,296 --> 00:04:53,164
Então, vamos lá.

121
00:04:53,164 --> 00:04:55,874
Aqui no nosso código, então,
eu vou começar entre os parênteses,

122
00:04:55,874 --> 00:04:59,374
colocando o meu parâmetro,
que eu vou chamar de nome.

123
00:04:59,374 --> 00:05:01,714
E no Python, a gente
tem a tipagem dinâmica.

124
00:05:01,714 --> 00:05:05,324
Isso significa que eu posso
deixar o meu código dessa forma,

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

126
00:05:09,054 --> 00:05:11,884
Mas caso eu queira deixar
mais claro para algum desenvolvedor

127
00:05:11,884 --> 00:05:14,864
que pegar o nosso código,
eu posso colocar aqui do lado,

128
00:05:14,864 --> 00:05:18,123
na frente dos dois pontos,
o tipo str.

129
00:05:18,123 --> 00:05:22,174
Lembra, isso não vai mudar
na prática nada dentro da linguagem,

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

131
00:05:24,084 --> 00:05:26,684
entenda que eu estou esperando
que ele mande um string.

132
00:05:26,684 --> 00:05:30,404
Se ele mandar um número, o Python
não vai reclamar nesse momento.

133
00:05:30,404 --> 00:05:33,034
Mas eu estou informando para ele
que o comportamento esperado

134
00:05:33,034 --> 00:05:34,434
é que ele mande um texto.

135
00:05:34,434 --> 00:05:35,694
Tá bom? Então vamos lá.

136
00:05:35,694 --> 00:05:39,264
Agora que dentro do contexto
da minha função eu tenho essa variável,

137
00:05:39,264 --> 00:05:40,659
eu posso usar ela.

138
00:05:40,659 --> 00:05:42,694
Então eu vou basicamente
copiar ela aqui

139
00:05:42,694 --> 00:05:45,234
e remover a palavra aluno
da minha mensagem,

140
00:05:45,234 --> 00:05:47,604
porque agora eu vou fazer
uma concatenação simples.

141
00:05:47,604 --> 00:05:50,674
E para isso, eu vou colocar
aqui na frente do sinal de mais

142
00:05:50,674 --> 00:05:51,904
a variável nome.

143
00:05:51,904 --> 00:05:54,174
E vamos ver o que acontece
se eu executar o meu código

144
00:05:54,174 --> 00:05:55,634
do jeito que ele está.

145
00:05:55,634 --> 00:05:56,447
Pronto.

146
00:05:56,447 --> 00:05:59,664
A gente agora tem um erro,
porque eu defini um parâmetro

147
00:05:59,664 --> 00:06:01,964
e ele é um parâmetro posicional.

148
00:06:01,964 --> 00:06:04,694
Ou seja, eu posso definir
vários parâmetros.

149
00:06:04,694 --> 00:06:07,064
A ordem com que eu passar
eles vai ser a ordem

150
00:06:07,064 --> 00:06:10,124
com que o Python vai alocá-los
dentro das variáveis.

151
00:06:10,124 --> 00:06:11,174
Vamos lá.

152
00:06:11,174 --> 00:06:13,974
Isso significa que se eu tivesse
uma outra variável aqui,

153
00:06:13,974 --> 00:06:18,254
por exemplo, idade, eu teria
que passar aqui embaixo,

154
00:06:18,254 --> 00:06:20,584
dentro da invocação
da minha função,

155
00:06:20,584 --> 00:06:22,154
a primeira variável
que é o nome.

156
00:06:22,154 --> 00:06:24,364
Por exemplo, "Aluno".

157
00:06:24,364 --> 00:06:27,354
E se eu quiser passar idade,
eu coloco aqui na frente.

158
00:06:27,354 --> 00:06:29,844
Repara que a própria IDE
já vai dando dicas para a gente

159
00:06:29,844 --> 00:06:32,434
de como que a gente está
esperando receber os valores.

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

161
00:06:35,524 --> 00:06:37,154
Então eu vou remover a idade.

162
00:06:37,154 --> 00:06:40,404
E se a gente executa novamente
o nosso código, agora sim.

163
00:06:40,404 --> 00:06:43,774
A gente tem a mesma mensagem
de antes, mas um pouco diferente.

164
00:06:43,774 --> 00:06:46,464
Porque essa mensagem agora,
ela está parametrizável.

165
00:06:46,464 --> 00:06:49,274
Ou seja, a gente consegue
controlar o comportamento

166
00:06:49,274 --> 00:06:51,304
daquela função do lado de fora.

167
00:06:51,304 --> 00:06:54,254
E se eu quiser usar essa função
quantas vezes eu quiser,

168
00:06:54,254 --> 00:06:55,774
eu posso sem problema nenhum.

169
00:06:55,774 --> 00:06:57,824
Imagina, por exemplo,
que aqui embaixo

170
00:06:57,824 --> 00:06:59,914
eu vou querer executar
ela mais duas vezes.

171
00:06:59,914 --> 00:07:03,624
Só que dessa vez,
colocando "Aluna",

172
00:07:03,624 --> 00:07:04,704
e aqui embaixo,

173
00:07:04,704 --> 00:07:06,524
talvez você esteja
sentindo falta disso.

174
00:07:06,524 --> 00:07:07,914
Então, "Mundo".

175
00:07:07,914 --> 00:07:11,624
Se eu limpar o meu terminal
e executar novamente a aplicação,

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

177
00:07:14,534 --> 00:07:17,244
sendo que cada uma delas
reaproveitou o código

178
00:07:17,244 --> 00:07:19,884
que a gente definiu na função,
mas foi parametrizado

179
00:07:19,884 --> 00:07:21,934
para que o comportamento
fosse diferente.

180
00:07:21,934 --> 00:07:23,104
Incrível, né?

181
00:07:23,104 --> 00:07:25,044
A gente construiu uma função simples,

182
00:07:25,044 --> 00:07:27,744
mas as funções estão
por todo lugar na linguagem.

183
00:07:27,744 --> 00:07:30,544
Sejam funções nativas
ou funções de pacote que a gente

184
00:07:30,544 --> 00:07:32,704
vai uma hora ou outra
até que acabar usando.

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

186
00:07:36,144 --> 00:07:38,504
Tenta adicionar um outro parâmetro,
um outro tipo,

187
00:07:38,504 --> 00:07:41,384
faz condicionais lá dentro,
loops, quem sabe.

188
00:07:41,384 --> 00:07:42,224
Experimenta.

189
00:07:42,224 --> 00:07:45,834
Ganhe afinidade com essa sintaxe aqui
e vamos ver até onde você chega.