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

2
00:00:10,440 --> 00:00:13,170
nova, 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:17,654
o que já está feito,
a gente começa a conversar

5
00:00:17,654 --> 00:00:20,022
sobre função nativa
para cá e para lá, e agora

6
00:00:20,022 --> 00:00:22,352
finalmente chegou
o momento da gente entender

7
00:00:22,352 --> 00:00:24,655
o que são funções
para que servem e construir

8
00:00:24,655 --> 00:00:27,270
a nossa primeira.
Como a gente já comentou, a gente

9
00:00:27,270 --> 00:00:30,080
consegue reaproveitar bastante
coisa no desenvolvimento

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

11
00:00:31,988 --> 00:00:34,826
Se a gente quisesse, a gente
até poderia fazer isso

12
00:00:34,826 --> 00:00:37,840
tudo do zero, mas tem alguns
problemas nessa abordagem.

13
00:00:37,840 --> 00:00:40,170
Imagina que dentro da sua
aplicação, você tem

14
00:00:40,170 --> 00:00:42,361
que exibir uma mensagem
para algum usuário.

15
00:00:42,361 --> 00:00:45,179
Dentro dessa mensagem,
você provavelmente vai ter

16
00:00:45,179 --> 00:00:48,009
o nome do usuário e alguns
elementos extras, como

17
00:00:48,009 --> 00:00:51,116
um prefixo ou sufixo, alguma
coisa desse tipo. Pronto,

18
00:00:51,116 --> 00:00:54,009
esse seu código vai funcionar
mais, felizmente ou,

19
00:00:54,009 --> 00:00:56,873
infelizmente, mais para frente
no seu código, você

20
00:00:56,873 --> 00:00:59,693
vai ter que repetir aquele
mesmo comportamento. E

21
00:00:59,693 --> 00:01:02,619
conforme sua aplicação for
crescendo, provavelmente

22
00:01:02,619 --> 00:01:05,670
em outros lugares você vai
ter que fazer isso também.

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

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

25
00:01:11,815 --> 00:01:14,250
Não só a gente não está
conseguindo reaproveitar

26
00:01:14,250 --> 00:01:16,698
aquele código, porque
ele está espalhado no meio

27
00:01:16,698 --> 00:01:19,288
da nossa aplicação, como
se a gente precisar trocar

28
00:01:19,288 --> 00:01:21,642
aquele comportamento
para adicionar ou remover

29
00:01:21,642 --> 00:01:23,721
alguma característica,
isso vai ser muito

30
00:01:23,721 --> 00:01:26,108
complicado, porque a gente
vai ter que depender

31
00:01:26,108 --> 00:01:28,639
de ferramentas de busca
para procurar algum trecho

32
00:01:28,639 --> 00:01:31,580
de código e então alterá-lo
em todos os lugares.

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

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

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

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

37
00:01:42,608 --> 00:01:45,524
Com elas, a gente consegue
criar blocos de código

38
00:01:45,524 --> 00:01:48,393
parametrizáveis e executar
uma lógica específica

39
00:01:48,393 --> 00:01:51,783
quantas vezes a gente quiser.
Funções existem basicamente

40
00:01:51,783 --> 00:01:54,541
todas as linguagens,
de uma forma ou de outra.

41
00:01:54,541 --> 00:01:57,445
E a característica principal
delas é isolar bloco

42
00:01:57,445 --> 00:02:00,128
de código para reaproveitamento.
Sendo assim,

43
00:02:00,128 --> 00:02:03,038
a gente consegue implementar
o que a gente quiser

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

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

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

47
00:02:10,150 --> 00:02:12,078
e aonde ela estiver
sendo referenciada,

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

49
00:02:14,550 --> 00:02:16,758
legal. Agora que você
entendeu a motivação e,

50
00:02:16,758 --> 00:02:19,270
mais ou menos, a ideia
por trás das funções,

51
00:02:19,270 --> 00:02:21,524
vamos ver, na prática, como
que isso funciona no Python.

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

53
00:02:23,090 --> 00:02:25,104
Aqui no VS Code, eu já
tenho meu arquivo main.

54
00:02:25,104 --> 00:02:28,010
py criado. Então, vamos começar
definindo a nossa função.

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

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

57
00:02:32,702 --> 00:02:34,848
de fazer e é assim
que a gente faz no Python.

58
00:02:34,848 --> 00:02:36,907
Eu vou começar, então,
aqui colocando o nome

59
00:02:36,907 --> 00:02:39,345
da minha função, que vai
ser exatamente minha função.

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

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

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

63
00:02:47,371 --> 00:02:49,758
Pronto.
A partir de agora, eu estou livre

64
00:02:49,758 --> 00:02:52,348
para desenvolver
o corpo da minha função.

65
00:02:52,348 --> 00:02:55,431
Ou seja, o que eu quero
que seja executado quando

66
00:02:55,431 --> 00:02:58,895
essa função for invocada.
No nosso exemplo, a gente vai

67
00:02:58,895 --> 00:03:02,078
colocar apenas um print,
escrevendo alguma mensagem

68
00:03:02,078 --> 00:03:06,450
simples, como, por exemplo,
olá, aluno. E salvar o arquivo.

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

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

71
00:03:11,860 --> 00:03:15,302
Veja só. Aqui no terminal,
eu vou escrever python.

72
00:03:15,302 --> 00:03:19,530
exe, ponto barra e o
nome do meu arquivo.

73
00:03:19,530 --> 00:03:23,614
Ponto barra, main.py. E se eu der
um enter, repara que a aplicação

74
00:03:23,614 --> 00:03:27,750
até executou, mas não aconteceu
nada de muito interessante.

75
00:03:27,750 --> 00:03:30,142
Isso foi, basicamente,
porque eu declarei a minha

76
00:03:30,142 --> 00:03:32,790
função, mas eu não invoquei
ela em lugar algum.

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

78
00:03:35,298 --> 00:03:38,100
Eu consigo escrever código
lá dentro, mas ele só

79
00:03:38,100 --> 00:03:40,342
é executado, de fato,
quando eu invoco

80
00:03:40,342 --> 00:03:43,235
essa função.
Então, vamos lá aqui no nosso código.

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

82
00:03:46,185 --> 00:03:48,664
E para fazer isso,
basta eu executar o nome

83
00:03:48,664 --> 00:03:51,430
dessa função e colocar
aqui os parênteses.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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