0:00:00.150,0:00:02.520
- Let's trace a program step by step.

0:00:02.520,0:00:04.050
This is a common pattern we'll use

0:00:04.050,0:00:06.750
to understand what the computer[br]is doing under the hood

0:00:06.750,0:00:08.490
when we press the Run button.

0:00:08.490,0:00:10.710
Tracing program execution like this

0:00:10.710,0:00:12.600
helps us better read and write programs

0:00:12.600,0:00:14.400
because we can start to predict

0:00:14.400,0:00:16.590
what the computer's going[br]to do with each instruction

0:00:16.590,0:00:17.640
without having to go through

0:00:17.640,0:00:19.770
a long process of trial and error.

0:00:19.770,0:00:21.660
For now, we'll write this all out together

0:00:21.660,0:00:23.340
so we can make sense of[br]what's happening here,

0:00:23.340,0:00:26.010
but eventually, we'll get[br]familiar enough with Python

0:00:26.010,0:00:27.820
where we can trace small[br]blocks of code like this

0:00:27.820,0:00:29.013
in our heads.

0:00:30.360,0:00:31.410
When you press Run,

0:00:31.410,0:00:33.690
the computer looks at[br]your program line by line.

0:00:33.690,0:00:35.580
It isn't smart enough to zoom out

0:00:35.580,0:00:38.130
and look at the big picture[br]and try and understand

0:00:38.130,0:00:40.590
what the program is[br]trying to do as a whole.

0:00:40.590,0:00:43.350
When I say line by line, I literally mean

0:00:43.350,0:00:46.530
that the computer is going to[br]load each line of your program

0:00:46.530,0:00:48.960
into its working memory one by one.

0:00:48.960,0:00:50.550
And then with one instruction

0:00:50.550,0:00:51.840
loaded into its working memory,

0:00:51.840,0:00:54.660
it's going to interpret that[br]instruction in isolation,

0:00:54.660,0:00:57.000
in total isolation.

0:00:57.000,0:00:59.430
Now, remember that the[br]computer is not a mind reader.

0:00:59.430,0:01:01.710
So it doesn't understand any nuance

0:01:01.710,0:01:03.870
or intention behind your instruction.

0:01:03.870,0:01:06.660
It's only going to do literally[br]what that instruction says

0:01:06.660,0:01:09.354
according to whatever rules of Python.

0:01:09.354,0:01:12.180
Let's see that in action[br]by tracing this program.

0:01:12.180,0:01:14.130
The computer takes the[br]first line of the program

0:01:14.130,0:01:16.140
and loads that into working memory.

0:01:16.140,0:01:17.580
Then the first thing it's gonna do

0:01:17.580,0:01:20.490
is look for any expressions to evaluate.

0:01:20.490,0:01:22.157
Remember that evaluating an expression

0:01:22.157,0:01:25.350
just simplifies it down to a single value.

0:01:25.350,0:01:26.880
Here we have the expression,

0:01:26.880,0:01:30.270
the integer four plus the float, 20.55.

0:01:30.270,0:01:34.440
And that evaluates to the float 24.55.

0:01:34.440,0:01:36.540
Now, all our expressions[br]have been simplified,

0:01:36.540,0:01:38.790
so the computer's gonna[br]peek outside the parentheses

0:01:38.790,0:01:41.790
and ask, "Well, what did you[br]want me to do with this value?"

0:01:41.790,0:01:44.340
The instruction print[br]tells it to take the value

0:01:44.340,0:01:47.610
inside the parentheses and go[br]display that in the console.

0:01:47.610,0:01:51.840
So it goes over here and it prints 24.55.

0:01:51.840,0:01:53.280
This instruction is complete,

0:01:53.280,0:01:55.290
so the computer's ready[br]to move to the next step,

0:01:55.290,0:01:58.080
but first it wants to[br]optimize its brain space.

0:01:58.080,0:02:01.140
It doesn't really need to[br]remember this instruction anymore,

0:02:01.140,0:02:02.550
it doesn't need this information.

0:02:02.550,0:02:06.150
So it just clears out its[br]working memory and forgets,

0:02:06.150,0:02:08.940
and that makes room for[br]the next instruction.

0:02:08.940,0:02:10.770
Now, the computer loads the second line

0:02:10.770,0:02:12.210
into its working memory.

0:02:12.210,0:02:15.390
And again, it looks for any[br]expressions to evaluate.

0:02:15.390,0:02:17.520
It sees the expression three plus two,

0:02:17.520,0:02:21.300
and it simplifies that[br]down to the integer five.

0:02:21.300,0:02:24.150
Notice that there's no[br]print instruction here.

0:02:24.150,0:02:26.400
We didn't actually ask the computer

0:02:26.400,0:02:28.200
to do anything with that value.

0:02:28.200,0:02:29.407
So the computer's thinking,

0:02:29.407,0:02:31.380
"Well, hey, I just did all this work.

0:02:31.380,0:02:32.910
I figured out the answer's five,

0:02:32.910,0:02:35.130
but I guess you don't want me to tell you.

0:02:35.130,0:02:39.600
So it shrugs whatever, and it[br]clears its working memory out,

0:02:39.600,0:02:42.720
forgets that five, and just moves on.

0:02:42.720,0:02:44.331
Third line, the computer loads,

0:02:44.331,0:02:47.970
print the string learn[br]plus the string space.

0:02:47.970,0:02:49.950
Careful, this is not the empty string.

0:02:49.950,0:02:51.330
There's one little space character

0:02:51.330,0:02:53.400
in between these quotation marks.

0:02:53.400,0:02:54.843
Plus the string more.

0:02:55.710,0:02:58.040
But there are two operators[br]in this expression.

0:02:58.040,0:02:59.880
There's two plus signs.

0:02:59.880,0:03:02.640
So the computer's actually going[br]to evaluate this expression

0:03:02.640,0:03:04.920
in two steps, reading left to right.

0:03:04.920,0:03:08.790
First, it evaluates the[br]expression, learn plus space.

0:03:08.790,0:03:10.410
Now, when we add strings,

0:03:10.410,0:03:12.090
remember that we are concatenating.

0:03:12.090,0:03:13.440
We are smushing together.

0:03:13.440,0:03:16.200
So we get the string learn space.

0:03:16.200,0:03:18.180
Then we add the string more.

0:03:18.180,0:03:21.153
We concatenate and we[br]get learn space more.

0:03:21.990,0:03:23.340
We're down to a single value,

0:03:23.340,0:03:25.980
so the computer peaks[br]outside the parentheses,

0:03:25.980,0:03:27.870
sees that we wanted to print that value,

0:03:27.870,0:03:31.590
and it prints learn space[br]more in the console.

0:03:31.590,0:03:33.390
Finally, it clears its working memory

0:03:33.390,0:03:35.670
and it moves to the next line.

0:03:35.670,0:03:38.850
What do you think the last[br]two lines of this program do?

0:03:38.850,0:03:41.050
Take a second and try[br]and trace it yourself.

0:03:42.919,0:03:45.660
Okay, this instruction has the expression,

0:03:45.660,0:03:49.830
the string 81 plus the string 19.42.

0:03:49.830,0:03:52.470
Now, these may look like[br]integers and floats,

0:03:52.470,0:03:54.990
but because there are[br]quotation marks around them,

0:03:54.990,0:03:57.330
the computer's going to[br]treat them like strings.

0:03:57.330,0:03:59.190
So when we evaluate this expression,

0:03:59.190,0:04:00.840
we're concatenating strings

0:04:00.840,0:04:05.700
and we get the string 8119.42.

0:04:05.700,0:04:06.990
Nothing left to simplify here.

0:04:06.990,0:04:09.360
So the computer pops[br]outside the parentheses,

0:04:09.360,0:04:14.070
sees the print, and then[br]prints 8119.42 to the console.

0:04:14.070,0:04:15.450
Then it clears out working memory

0:04:15.450,0:04:17.130
and moves to the last line.

0:04:17.130,0:04:19.350
The computer loads the[br]last line of the program

0:04:19.350,0:04:20.790
into working memory.

0:04:20.790,0:04:23.370
Notice that this whole thing[br]inside the parentheses here

0:04:23.370,0:04:25.470
is surrounded by quotation marks.

0:04:25.470,0:04:28.170
That means this is already a single value.

0:04:28.170,0:04:30.450
It's the string, the two character,

0:04:30.450,0:04:32.670
space character, plus[br]character, space character,

0:04:32.670,0:04:33.810
two character.

0:04:33.810,0:04:37.200
It's not the expression[br]the integer two plus two.

0:04:37.200,0:04:39.390
Because we already have a single value,

0:04:39.390,0:04:40.650
there's nothing to simplify here.

0:04:40.650,0:04:43.140
So the computer pops out the parentheses,

0:04:43.140,0:04:44.550
sees the instruction print,

0:04:44.550,0:04:47.130
prints two space plus[br]space two to the console,

0:04:47.130,0:04:49.080
and clears working memory.

0:04:49.080,0:04:50.760
Then it jumps to the[br]next line of the program,

0:04:50.760,0:04:52.410
and oh, there is no next line.

0:04:52.410,0:04:54.540
We are at the end, we did it.

0:04:54.540,0:04:56.970
So the computer terminates[br]the program execution,

0:04:56.970,0:05:00.930
it exits, and we have a final[br]result here in the console.

0:05:00.930,0:05:02.381
Wanna check my work?

0:05:02.381,0:05:04.200
Copy this program into a code editor

0:05:04.200,0:05:05.550
and run it for yourself.

0:05:05.550,0:05:06.873
Is the result the same?