Showing Revision 2 created 08/01/2014 by Fran Ontanaya.

1. Title:
   02-11 Using Procedures
2. Description:

   02-11 Usando Procedimentos

3. 0 0:00 - 0:04
   Infelizmente, ainda não estamos prontos para ficar completamente felizes.
4. 4000 0:04 - 0:07
   Sebastian me disse que ainda levará alguns anos até que eu possa ter
5. 7000 0:07 - 0:11
   meu próprio carro autônomo. Mas o maior problema é que ainda não falamos sobre
6. 11000 0:11 - 0:13
   como usar um procedimento.
7. 13000 0:13 - 0:17
   Tudo o que fizemos foi definir um. Até que possamos realmente usá-los,
8. 17000 0:17 - 0:19
   não temos uma boa razão para ficar muito felizes.
9. 19000 0:19 - 0:22
   Vamos aprender como usá-los a seguir, e então poderemos ficar mais felizes.
10. 22000 0:22 - 0:25
    Agora, vamos aprender como usar um procedimento.
11. 25000 0:25 - 0:32
    A maneira como usamos procedimento é: precisamos do nome do procedimento, seguido de
12. 32000 0:32 - 0:36
    ( seguido de uma lista de entradas e ).
13. 36000 0:36 - 0:40
    O número de entradas pode ser qualquer, mas deve casar com o número de entradas
14. 40000 0:40 - 0:42
    que o procedimento espera.
15. 42000 0:42 - 0:44
    Essas entradas são algumas vezes chamadas de operandos.
16. 44000 0:44 - 0:46
    E algumas vezes chamadas de argumentos.
17. 46000 0:46 - 0:48
    Não vamos discutir sobre isso.
18. 48000 0:48 - 0:50
    Vamos simplesmente chamá-las de entradas.
19. 50000 0:50 - 0:52
    Você de fato já fez algo bem similar a isso.
20. 52000 0:52 - 0:57
    Voltando na Unidade 1, você aprendeu a usar find sobre strings.
21. 57000 0:57 - 0:59
    Com find, você pode passar uma ou duas entradas.
22. 59000 0:59 - 1:01
    A primeira entrada era uma string:
23. 61000 1:01 - 1:04
    a string pela qual você estava procurando -- essa era a primeira entrada;
24. 64000 1:04 - 1:07
    e a segunda entrada poderia ser um número: a posição onde você começa
25. 67000 1:07 - 1:09
    a pesquisar por essa string.
26. 69000 1:09 - 1:13
    Nós usamos find de várias maneiras na Unidade 1, e você também usou
27. 73000 1:13 - 1:15
    nos exercícios da Unidade 1.
28. 75000 1:15 - 1:17
    find é um pouco diferente dos procedimentos que você vai definir aqui.
29. 77000 1:17 - 1:19
    Em primeir lugar, ele é pré-definido.
30. 79000 1:19 - 1:22
    A outra coisa que é diferente é que, ao invés de ter apenas find, nós temos
31. 82000 1:22 - 1:25
    outra entrada que está aqui.
32. 85000 1:25 - 1:31
    Temos o string no qual vamos fazer a pesquisa -- digamos que ele fosse
33. 91000 1:31 - 1:34
    a variável page -- isso é, de fato, uma outra entrada para find.
34. 94000 1:34 - 1:38
    Mais adiante vamos falar sobre porque isso é feito de maneira diferente, mas é
35. 98000 1:38 - 1:41
    bastante semelhante a chamar um procedimento em que uma das entradas está aqui,
36. 101000 1:41 - 1:43
    e as outras duas estão aqui.
37. 103000 1:43 - 1:46
    É um pouco diferente disso, e não vamos ver isso neste curso, mas
38. 106000 1:46 - 1:50
    em um curso posterior você vai aprender mais sobre o que isso significa.
39. 110000 1:50 - 1:55
    Para todos os procedimentos que você vai definir aqui, não haverá nenhum
40. 115000 1:55 - 1:56
    objecto sobre o qual eles serão invocados.
41. 116000 1:56 - 2:00
    Simplesmente teremos o procedimento a chamar e os argumentos, ou operandos, ou entradas --
42. 120000 2:00 - 2:03
    como você queira chamá-los -- que serão passados.
43. 123000 2:03 - 2:06
    Vamos ver como isso funciona, com um procedimento simples.
44. 126000 2:06 - 2:10
    Eu vou definir o procedimento rest_of_string, que vai ter
45. 130000 2:10 - 2:13
    um parâmetro s -- isso significa que ele tem uma entrada, e vamos usar o nome
46. 133000 2:13 - 2:16
    s para nos referirmos ao valor dessa entrada.
47. 136000 2:16 - 2:21
    Ele vai retornar a string que vai desde o caractere na posição 1 até o final da string.
48. 141000 2:21 - 2:25
    Vamos usar o operador de indexação de string: return s[1:].
49. 145000 2:25 - 2:31
    Isso avalia para a string obtida removendo-se a primeira letra; portanto, toda a string a partir
50. 151000 2:31 - 2:33
    da posição 1 até o final da string.
51. 153000 2:33 - 2:35
    É isso que é retornado.
52. 155000 2:35 - 2:39
    Então, a saída de rest_of_string é esta nova string, que começa da
53. 159000 2:39 - 2:42
    segunda letra da string de entrada.
54. 162000 2:42 - 2:45
    Aqui está um exemplo de como usar este procedimento.
55. 165000 2:45 - 2:47
    Podemos chamá-lo diretamente.
56. 167000 2:47 - 2:51
    Podemos dizer print rest_of_string --
57. 171000 2:51 - 2:53
    este é o nosso procedimento --
58. 173000 2:53 - 2:56
    e agora temos ( e vamos passar uma entrada.
59. 176000 2:56 - 2:59
    rest_of_string tem 1 parâmentro e, portanto, precisamos passar de 1 entrada
60. 179000 2:59 - 3:02
    para ele, que deve ser uma string.
61. 182000 3:02 - 3:05
    Vamos passar a string 'audacity'.
62. 185000 3:05 - 3:08
    O que acontece quando chamamos um procediento como esse é que a execução desvia
63. 187813 3:08 - 3:10
    para o corpo desse procedimento.
64. 190000 3:10 - 3:11
    Podemos pensar no que o interpretador está fazendo agora.
65. 190566 3:11 - 3:17
    Ao invés de executar este código aqui, o interpretador desvia:
66. 197000 3:17 - 3:21
    quando chamamos um procedimento, ele desvia para executar o código que está dentro do procedimento.
67. 201000 3:21 - 3:26
    Ele vai atribuir aos parâmetros os valores que são passados como entrada.
68. 206000 3:26 - 3:30
    Podemos pensar nisso como sendo uma atribuição, que diz que agora o valor de
69. 210000 3:30 - 3:32
    s é o valor dessa entrada que está sendo passada.
70. 211974 3:32 - 3:36
    Agora, vamos avaliar o corpo do procedimento.
71. 216000 3:36 - 3:39
    Neste caso, existe apenas um comando -- este comando return.
72. 219000 3:39 - 3:43
    Vamos encontrar o valor de s[1:] --
73. 223000 3:43 - 3:47
    o resultado disso será a string 'udacity' --
74. 227000 3:47 - 3:49
    e então chegamos ao return.
75. 229000 3:49 - 3:51
    O que return significa é que vamos desviar de volta.
76. 231000 3:51 - 3:56
    Vamos voltar para onde o procedimento foi chamado, mas agora realemte
77. 236000 3:56 - 3:58
    temos um resultado.
78. 238000 3:58 - 4:03
    Quando voltamos, o valor para o qual isso é avaliado é o valor que nós
79. 243000 4:03 - 4:04
    retornamos.
80. 244000 4:04 - 4:07
    Neste caso, é a string 'udacity'.
81. 247050 4:07 - 4:09
    Então, não temos ainda nosso carro autônomo,
82. 248556 4:09 - 4:11
    mas agora você já sabe definir e usar procedimentos.
83. 250867 4:11 - 4:13
    Esse é um conceito realmente poderoso!
84. 252902 4:13 - 4:15
    Tudo o que vamos fazer no resto do curso e quase tudo
85. 254993 4:15 - 4:19
    que todo mundo faz em programação de computadores tem a ver com dedinir
86. 258529 4:19 - 4:21
    procedimentos e usar procedimentos.
87. 260697 4:21 - 4:23
    Agora podemos abrir um grande sorriso.
88. 262778 4:23 - 4:27
    Podemos pensar em nossos procedimentos em termos de mapeamento de entradas em saídas.
89. 266777 4:27 - 4:30
    Podemos pensar pensar em nós, humanos, também como mapeamentos de entradas em saídas:
90. 270396 4:30 - 4:33
    temos entradas vindo de nossos olhos, por meio da
91. 273065 4:33 - 4:36
    boca, e até pelo nosso nariz.
92. 275689 4:36 - 4:39
    Eu não vou tentar desenhar nenhuma das saídas do nosso procedimento 'humano', mas como
93. 279081 4:39 - 4:41
    procedimentos são um conceito tão importante, vamos ter vários
94. 281495 4:41 - 4:44
    testes agora, para verificar se você entendeu bem esse conceito.