Showing Revision 7 created 05/25/2016 by Udacity Robot.

1. Title:
   Using Procedures - Intro to Computer Science
2. Description:

3. 0 0:00 - 0:04
   Unfortunately, we're not quite ready to be all smiley.
4. 4000 0:04 - 0:07
   Sebastian tells me it's going to be a few years before I can get
5. 7000 0:07 - 0:11
   my own self-driving car, but the bigger problem is we haven't yet talked about
6. 11000 0:11 - 0:13
   how to actually use the procedure.
7. 13000 0:13 - 0:17
   All we've done is make them; until we can actually use them
8. 17000 0:17 - 0:19
   we don't have a good reason to be really happy yet.
9. 19000 0:19 - 0:22
   We're going to learn how to use them next, then we'll be back to being smiley.
10. 22000 0:22 - 0:25
    Now we are going to learn how to use a procedure.
11. 25000 0:25 - 0:32
    The way to use a procedureâÂÂwe need the name of the procedure, followed by
12. 32000 0:32 - 0:36
    a left paren, followed by a list of inputs.
13. 36000 0:36 - 0:40
    There could be any number of inputs, but it has to match the number of inputs
14. 40000 0:40 - 0:42
    the procedure expects.
15. 42000 0:42 - 0:44
    These inputs are sometimes called "operands."
16. 44000 0:44 - 0:46
    They are sometimes called "arguments."
17. 46000 0:46 - 0:48
    We're not going to argue about that.
18. 48000 0:48 - 0:50
    We're just going to call them inputs.
19. 50000 0:50 - 0:52
    You have actually already done something quite similar to this.
20. 52000 0:52 - 0:57
    Back in Unit 1, you learned about using "find" on "strings."
21. 57000 0:57 - 0:59
    With "find" you would pass in one or two inputs.
22. 59000 0:59 - 1:01
    The first input was a "string."
23. 61000 1:01 - 1:04
    That was the string you are looking forâÂÂthat's the first inputâÂÂ
24. 64000 1:04 - 1:07
    and the second input could be a numberâÂÂthe position where you start
25. 67000 1:07 - 1:09
    looking for that string.
26. 69000 1:09 - 1:13
    We use "find" in many ways in Unit 1, as well as you used it
27. 73000 1:13 - 1:15
    yourself in the homework for Unit 1.
28. 75000 1:15 - 1:17
    "Find" is a little different from the procedures that you define yourself.
29. 77000 1:17 - 1:19
    First of all, it's built in.
30. 79000 1:19 - 1:22
    The other thing that was different is that, instead of just having "find," we had
31. 82000 1:22 - 1:25
    another input that was really over here.
32. 85000 1:25 - 1:31
    We have the string that we were doing the "find" inâÂÂlet's say it was
33. 91000 1:31 - 1:34
    in the variable pageâÂÂthat's really another input to find.
34. 94000 1:34 - 1:38
    We'll talk in a later class about why that's done differently, but it's
35. 98000 1:38 - 1:41
    very similar to calling a procedure where one of the inputs is over hereâÂÂ
36. 101000 1:41 - 1:43
    the other two are here.
37. 103000 1:43 - 1:46
    It's a little different from that and we won't get into that in this course but
38. 106000 1:46 - 1:50
    in a later course you'll learn more about what this really means.
39. 110000 1:50 - 1:55
    For all the procedures that you define yourself, we won't have any
40. 115000 1:55 - 1:56
    object to invoke them on.
41. 116000 1:56 - 2:00
    We'll just have the procedure to call and the arguments or operands or inputsâÂÂ
42. 120000 2:00 - 2:03
    as you like to call themâÂÂto pass in.
43. 123000 2:03 - 2:06
    Let's see how that works with a simple procedure.
44. 126000 2:06 - 2:10
    I am going to define the procedure "rest_of_string," and we'll give it the
45. 130000 2:10 - 2:13
    parameter "s," so that means it takes one input and we are going to use the
46. 133000 2:13 - 2:16
    name "s" to refer to the value of that input.
47. 136000 2:16 - 2:21
    We'll make it "return to string" from the first character to the end.
48. 141000 2:21 - 2:25
    We will use the "string" indexing operator "return s [1:]."
49. 145000 2:25 - 2:31
    This will evaluate to the "string," with the first letter removed, so all "strings" from
50. 151000 2:31 - 2:33
    position 1 until the end of the "string."
51. 153000 2:33 - 2:35
    That's what we return.
52. 155000 2:35 - 2:39
    So, the output of "rest_of_string" is that new string that starts from
53. 159000 2:39 - 2:42
    the second letter in the input "string."
54. 162000 2:42 - 2:45
    Here's an example of how to use this procedure.
55. 165000 2:45 - 2:47
    We could call it directly.
56. 167000 2:47 - 2:51
    We could say "print rest_of_string."
57. 171000 2:51 - 2:53
    That's our procedure.
58. 173000 2:53 - 2:56
    Now we are going to have our paren and we are going to pass in an input.
59. 176000 2:56 - 2:59
    There's one parameter to "rest_of_string," so we need one input
60. 179000 2:59 - 3:02
    to pass in and it should be a "string."
61. 182000 3:02 - 3:05
    We'll pass in the string 'audacity'.
62. 185000 3:05 - 3:08
    What happens when we call a procedure like this, execution will jump
63. 187813 3:08 - 3:10
    into the body of the procedure.
64. 190000 3:10 - 3:11
    We can think of what the interpreter is doing now.
65. 190566 3:11 - 3:17
    Instead of running the code here, the interpreter will move.
66. 197000 3:17 - 3:21
    When we call a procedure, it will jump to run the code inside the procedure.
67. 201000 3:21 - 3:26
    It will assign to the parameters the values passed in as the inputs.
68. 206000 3:26 - 3:30
    We can think of this as there being an assignment that says now the value of
69. 210000 3:30 - 3:32
    "s" is the value of this input that was passed in.
70. 211974 3:32 - 3:36
    Now we are going to evaluate the body of the procedure.
71. 216000 3:36 - 3:39
    In this case there's only one statementâÂÂit's this return statement.
72. 219000 3:39 - 3:43
    We are going to find this value, so s [1:].
73. 223000 3:43 - 3:47
    The result of that is going to be the string 'udacity'.
74. 227000 3:47 - 3:49
    Then we got to the return.
75. 229000 3:49 - 3:51
    What return means is we're going to jump back.
76. 231000 3:51 - 3:56
    We're jumping back to where we called the procedure, but now we actually
77. 236000 3:56 - 3:58
    have a result.
78. 238000 3:58 - 4:03
    When we jump back, the value that this evaluates to is whatever value we
79. 243000 4:03 - 4:04
    returned.
80. 244000 4:04 - 4:07
    In this case, it's the string 'udacity.'
81. 247050 4:07 - 4:09
    So we don't have our self driving car,
82. 248556 4:09 - 4:11
    but now you can define and use procedures.
83. 250867 4:11 - 4:13
    This is a really powerful concept
84. 252902 4:13 - 4:15
    Anything that we are going to do in the rest of the course and anything
85. 254993 4:15 - 4:19
    almost anyone does in programming computers is all about defining
86. 258529 4:19 - 4:21
    procedures and using procedures.
87. 260697 4:21 - 4:23
    Now we should have a big smile.
88. 262778 4:23 - 4:27
    We can think of our procedures in terms of mapping inputs to outputs.
89. 266777 4:27 - 4:30
    We can think of our humans as also mapping inputs to outputs.
90. 270396 4:30 - 4:33
    We have inputs coming in through the eyes, through the
91. 273065 4:33 - 4:36
    mouthâÂÂmaybe we even have a nose.
92. 275689 4:36 - 4:39
    I won't try to draw any of the outputs of our human procedure, but since
93. 279081 4:39 - 4:41
    procedures are such an important concept, we are going to have several
94. 281495 4:41 - 4:44
    quizzes now to check that you understand them well.