The following content is
provided under a Creative
Commons license.
Your support will help
MIT OpenCourseWare
continue to offer high quality
educational resources for free.
To make a donation or
view additional materials
from hundreds of MIT courses,
visit MIT OpenCourseWare
at ocw.mit.edu.
PROFESSOR: All right.
Let's get started, everyone.
So, good afternoon.
Welcome to the second lecture
of 60001 and also of 600.
So as always, if you'd like to
follow along with the lectures,
please go ahead and download
the slides and the code
that I'll provide at least an
hour before class every day.
All right.
So a quick recap of
what we did last time.
So last time, we talked a little
bit about what a computer is.
And I think the main takeaway
from the last lecture
is really that a computer only
does what it is told, right?
So it's not going to
spontaneously make
decisions on its own.
You, as the programmer,
have to tell it
what you want it to do
by writing programs.
OK.
So we talked about
simple objects.
And these objects were
of different types.
So we saw integers,
floats, and Booleans.
And then we did a couple of
simple operations with them.
Today, we're going to
look at a different--
a new type of object
called a string.
And then we're
going to introduce
some more powerful things
in our programming toolbox.
So we're going to look at how
to branch within a program,
and how to make things-- how
to make the computer repeat
certain tasks
within our program.
All right.
So let's begin by
looking at strings.
So strings are a
new object type.
We've seen so far
integers, which
were whole numbers, floats,
which were decimal numbers,
and we have seen Booleans,
which were true and false.
So strings are going to be
sequences of characters.
And these characters
can be anything.
They can be letters,
digits, special characters,
and also spaces.
And you tell Python that you're
talking about a string object
by enclosing it in
quotation marks.
So in this case, I'm creating an
object whose value is h-e-l-l-o
space t-h-e-r-e.
And Python knows it's a
string object, because we're
enclosing it in quotations.
They can be either double
quotes or single quotes,
but as long as you're
consistent, it doesn't matter.
And this object, we're binding
it to this variable named hi.
And we're using that using
the equals sign, which
is the assignment operator.
So from now on, whenever we
refer to this variable hi,
Python is going to say, oh,
I know what the value is,
and it's that string
of characters.
So we're going to
learn about two things
that you can do on strings
today, two operations.
One is to concatenate them.
And concatenation is
really just a fancy word
for using this plus
operator, which
means put the strings together.
So I have this original
variable named hi,
and I create a new
variable called name.
And in it, I'm going
to assign the string
a-n-a to the variable name.
And when I use the plus
operator in between hi and name,
those two variables,
Python is going
to look at the
values of those two,
and it's going to just
put them together.
OK.
I'm going to switch to Spider.
And this is just that
example from the slides.
So let's see what happens.
So I have the variable
hi, the variable name,
and I'm just concatenating
those two together.
And then I'm going
to print that out.
So if I run the code, notice
it prints out "hello thereana."
There's no space.
And there's no space because
the concatenation operator,
the plus, doesn't add
any spaces implicitly.
So again, another example
of just computer just
doing what it's told.
If we want to add a space,
we'd have to actually insert
the space manually.
So that's this
line here, line 8.
And in this line,
we're concatenating
the value of the
variable hi with a space.
Notice we're putting
it in quotation marks.
Just a space.
And then with name.
So if we'll go ahead
and print that value,
notice this was that
garbage greeting there.
And now we have a
proper greeting, right?
So that's the concatenation
between strings.
And then the other
thing we're going
to look at related to
strings is the star operator.
So that's this one
here on line 10.
So Python allows you to use
the star operator, which
stands for multiplication,
between a string and a number.
And when you do that,
Python interprets it
as repeat that string
that many number of times.
So in this case, I'm
creating a silly greeting,
and I'm concatenating the value
of hi, which is "hello there"
with the space plus the name.
So notice here, I'm
using parentheses
to tell Python, do this
operation first, and then
multiply whatever the
result of this is by 3.
So if I print that
out, it's going
to multiply the space
with my name three times,
and it's going to concatenate
that with "hello there."
So that's exactly what
it printed out there.
Last lecture, we talked
a little bit about print.
Today, I'm going to talk about
some nuances related to print.
So you use print to
interact with the user.
It's cool to write programs that
print things out to the user.
So the key word
here being print.
And then you put
parentheses after print.
And in the parentheses,
you put in whatever
you want to show the user.
So in this little
program, I have--
I created a variable named x.
I assigned it the value
1, and then I print 1.
Here, I'm casting.
So I'm taking the number
one, the integer 1,
and I'm casting it to a string.
And you'll see why in a moment.
So I want to bring
to your attention
a couple of things here.
So in the first print, I'm
using commas everywhere here.
And in the second
print, I'm using plus.
So by definition, if
you-- you can use commas
inside a print-- inside
the parentheses of print.
And if you use a comma, Python
is going to automatically
add a space in
between the two things
that the comma is in
between, the values.
So "my fav num is"
is the first thing.
And the second thing is
whatever's after the comma.
Let's take x.
So if you use a comma, Python
is going to automatically insert
a space for you.
Sometimes, you might want
that, sometimes you might not.
If you don't want that, you
can use the concatenation
operation, the plus.
And you can add all
of your little bits
together to create
one big string.
If you're using
commas, the items,
the objects in
between the commas,
do not all have to be strings.
That's the plus side
of using commas.
But the downside is you
get spaces everywhere.
If you use plus
operator, the plus side
is Python does exactly
what you tell it to do,
but everything has to
be a string object.
So "my fav num is"
is a string object.
You have to convert all of
your numbers to string objects,
and so on.
So if we look at Spider--
This is the same-- almost
the same code.
So here, I don't
have spaces anywhere.
So you can see that
the first line here
has commas everywhere.
So I'm going to have spaces in
between every one of the things
that I'm printing out.
This line here is sort of a
combination between commas
and concatenation.
So depending on where
I used the comma,
I'm going to have
an extra space.
And this line here just has
concatenation everywhere.
So if I run this, notice this
very first line added spaces
everywhere in between
all my objects.
The second one added
spaces somewhere.
And you can sort of trace
through and see exactly where
the spaces were added.
And the last line here
didn't add spaces anywhere.
So printing things out
to the console is nice,
but the second part of sort of
writing an interactive program
is getting input from the user.
And that's the more
interesting part.
So if you've done problem set 0,
you might have sort of already
tried to understand
this on your own.
But here we are.
So the way you get
input from the user
is using this command
function called input.
And inside the parentheses,
you type in whatever you'd
like to prompt the user with.
So in this case, in my
example here, I have input,
and then here I said
"type anything."
So the user is going
to see this text here,
and then the program
is just going to stop.
And it's going to
wait for the user
to type in something
and hit Enter.
As soon as the user
types in Enter,
whatever the user types
in becomes a string.
If a user types in a
number, for example,
that becomes the
string of that number.
So everything the
user types in is
going to be made as a string.
In this line right here,
whatever these the user types
in becomes a string.
And we're going to
bind that string object
to this variable named text.
So now, further in my
program, I could do whatever
I want with this variable text.
In this case, I'm
going to print 5*text.
OK.
So if the user, for
example, gave me "ha,"
I'm going to print "ha" 5 times.
If the user gave
me 5, what do you
think the user is--
what do you think
is going to be printed out?
25 or 5 five times?
Great.
Yes.
Exactly.
5 five times.
Oftentimes, you don't want to
work with numbers as strings,
right?
You want to work with
numbers as numbers, right?
So you have to cast.
And we learned
that last lecture.
You cast by just putting
in this little bit
right in front of the input.
And you can cast it to
whatever type you want.
Here I cast it to an int, but
you can also cast to a float
if you want to work with floats.
And that converts whatever
the user typed in,
as long as it's some number that
Python knows how to convert,
into the number itself.
So in this case, if
the user gives me 5,
I'm going to print out 5 times
5 instead of 5 five times.
So that's the code here.
So the first bit
is I'm going to get
the user to type in anything,
and I'm going to put 555.
And then when I type in the
number, since I'm casting it,
I'm going to do operations
with the number.
Yeah, question.
AUDIENCE: [INAUDIBLE]
PROFESSOR: Why do you
want to cast to-- oh.
The question is why do you
want to cast to a string?
Why do you want to cast
a string to a number?
AUDIENCE: [INAUDIBLE]
PROFESSOR: Oh, so
Python always--
whatever you type
in, just by default,
by definition of
the input command,
Python always makes it a string.
So if you want to
work with numbers,
you have to explicitly
tell it, I'm
going to work with a number.
So even if you give
it the number 5,
it's going to think
it's the string 5.
Yeah.
That's just how input works.
The next thing we're
going to look at
is ways that you can start
adding tests in your code.
And before you can start
adding tests in your code,
you need to be able to
do the actual tests.
So this is where comparison
operators come in.
So here, let's assume that
i and j are variables.
The following comparisons are
going to give you a Boolean.
So it's either going to say,
this is true or this is false.
So that's going to be your test.
So if i and j are
variables, you're
allowed to compare
ints with ints,
floats with floats,
strings with strings.
And you're allowed
to compare ints
and floats between
themselves, but you're not
allowed to compare a
string with a number.
In fact, if you even try to
do that in Python-- in Spider
here, if I try to say, is
the letter a greater than 5?
I get some angry
text right here.
And this just tells
me Python doesn't
understand the
meaning of-- how do I
compare a string with a number?
OK.
So just like in math, we can
do these usual comparisons.
We can say if something
is greater than something,
greater or equal to, less
than, less than or equal to.
I'd like to bring to your
attention the equality.
So the single equals
sign is an assignment.
So you're taking a
value, and you're
assigning it to a variable.
But when you're doing
the double equals sign,
this is the test for equality.
Is the value of
variable i the same
as the value of the variable j?
And that's, again,
also going to give you
a Boolean either true or false.
And you can also test for
inequality with the exclamation
equal.
So that means, is the
value of the variable i
not equal to the value
of the variable j?
True if yes, false if no.
OK.
So those are comparison
operators on integer,
floats, and strings.
On Booleans, you can do
some logic operators.
And the simplest
is just inverting.
So if a is a variable
that has a Boolean value,
not a is just
going to invert it.
So if a is true, then not
a is false, and vice versa.
This is a table that sort of
represents what I've said here.
So you can do-- you
can use and and or.
These are key words in Python.
You can use those two
key words on variables,
on Boolean variables.
And you get the result
a and b is only true
if both a and b are true.
And a or b is only false
if a and b are false.
And this is the complete
table just in case
you need to reference it.
All right.
So now that we have ways to do
logical-- question right there.
AUDIENCE: [INAUDIBLE]
PROFESSOR: Yeah, great question.
So what does it mean to
compare a string with a string
with the greater than?
So that's just going to compare
them, lexicographically.
So does it come first
in the alphabet?
So we can even test that out.
We can say, is a greater than b?
And it's false.
So b comes later in
the alphabet than a.
OK.
So now we have ways
to do the tests.
So we can add some branching
to our programming toolbox
now that we have
ways to do tests.
This is a map of MIT.
I'm going to go through
sort of a little example
to motivate why we would want
to do branching in our code.
And I think after this lecture,
you'll be able to sort of code
up this algorithm that
I'm going to explain.
So most of us see MIT as a maze.
I first did when I came here.
When I first came
here, obviously, I
signed up for the free
food mailing list.
And MIT, being a maze, I
had no idea where to go,
what the shortest
path was to free food.
So one way to think about
it is all I wanted to do
was get to the free food.
A very simple algorithm to
get there would be to say,
OK, I'm going take
my right hand,
and I'm going to make sure
that my right hand is always
on a wall.
And I'm going to go around
campus with my right hand
always being at a wall.
And eventually, I'll get
to where the free food is.
There might not be
any left, right?
But I'll be there.
So the algorithm is as follows.
If my right hand always
has to be on a wall,
then I'm going to
say, if there's
no wall to my right
side, then I'm
going to go right
until I get to a wall.
Then if there's a wall to my
right, and I can go forward,
I'm just going to
keep going forward.
If I keep going forward, and
there's a wall to my right
and in front of me, I'm going
to turn around and go left.
And then if there's a wall
to my right, in front of me,
and to the left, then I'm going
to turn around and go back.
So with this fairly
simple algorithm,
I just follow the path always
keeping the wall to my right.
And eventually, I would
end up where I need to be.
So notice, I used, just in
plain English, a few key words.
If, otherwise, things like that.
So in programming, we have
those same constructs.
And those same sort
of intuitive words
can be used to tell
Python to do something
or to do something else or to
choose from a different set
of possibilities.
And this way, we
can get the computer
to make decisions for us.
And you might be
thinking, well, you
said that computers can't
make decisions on their own.
It's not.
You, as programmers, are
going to build these decisions
into the program,
and all the computer
is going to do is going to reach
the decision point and say,
OK, this is a decision
point, should I go left
or should I go right?
Or which one do I pick?
And these sort of decisions are
created by you as a programmer.
And the computer just
has to make the decision
and choose a path.
OK.
So in programming, there's
three sort of simple ways
that you can add control
flow to your programs.
And that's making one
decision and choosing
whether to execute something
or execute something else.
The first is a simple if.
And given a program
that just linearly
has statements
that get executed,
whenever I reach
an if statement,
you're going to
check the condition.
The condition is
going to be something
that's going to get evaluated
to either true or false.
So I've reached
the condition here.
And if the condition
is true, then I'm
going to additionally execute
this extra set of expressions.
But if the condition
is false, then I'm
just going to keep going
through the program
and not execute that
extra set of instructions.
How does Python know which
instructions to execute?
They're going to be inside
this what we call code block.
And the code block is
denoted by indentation.
So it's going to be
everything that's
indented is part of
that if code block.
Typically, four
spaces is indentation.
OK.
So that's how you
write code that
decides whether to execute
this extra thing or not.
Now let's say I don't just
want to execute an extra thing,
I want to reach a
point where I say,
I'll either go down this path
or I'll do something else.
That's this right here.
So this if else construct
says this is my code,
I've reached my
decision point here,
if the condition
inside the if is true,
then I'm going to execute maybe
this set of statements here.
But if the condition
is not true,
then I'm not going to execute
that set of statements,
and instead I'm going to
execute under whatever else is.
So using this
construct, I'm either
going to do one set of
expressions or the other,
but never both.
And after I've executed
one or the other,
I'm going to continue on with
just the regular execution
of the program.
OK.
So we're able to either
choose one thing,
choose one thing or
another, but what if we want
to have more than one choice?
So if some number is equal
to zero, I want to do this.
If it's equal to 1,
I want to do this.
If it's equal to 2, I want
to do this, and so on.
That's where this
last one comes in.
And we introduced this other
key word here called elif.
So that stands for
short form for else if.
So first we check if
this condition is true.
So we're going
through our program,
we've reached our
decision point,
if the condition is true,
we're going to execute maybe
this set of instructions.
If the condition is
not true, maybe we'll
check-- if the
condition is not true,
we will check this
next condition.
That's part of the
elif right here.
And if that one's
true, we're going
to execute a different
set of instructions.
You can have more than one elif.
And depending on
which one's true,
you're going to execute a
different set of instructions.
And then this last else
is sort of a catch all
where if none of the previous
conditions were true,
then just do this last
set of expressions.
So in this case, you're
going to choose between one
of these three-- one
of these four roots,
or however many you have.
And then when you're
done making your choice,
you're going to execute the
remaining set of instructions.
So the way this works is if
more than one condition is true,
you're actually just going
to enter one of them.
And you're going to enter the
very first one that's true.
So you're never going
to enter more than one
of these code blocks.
You always enter one, and
you enter the first one
that evaluates to true.
So notice that we denoted
code blocks using indentation.
And that's actually
one of the things
that I really like about Python.
It sort of forces you to
write pretty code and nice
looking code and just
code that's very readable.
And that forces you to indent
everything that's a code block.
So you can easily see sort of
where the flow of control is
and where decision making
points are and things like that.
So in this particular example,
we have one if statement here,
and it checks if two
variables are equal.
And we have an if, elif, else.
And in this example, we're
going to enter either this code
block or this one or
this one, depending
on the variables of x and y.
And we're only going
into one code block.
And we'll enter the
first one that's true.
Notice you can have
nested conditionals.
So inside this first if,
we have another if here.
And this inner if is only going
to be checked when we enter
the first-- this outter if.
I do want to make
one point, though.
So sometimes, you might forget
to do the double equals sign
when you are checking for
equality, and that's OK.
If you just use one
equals sign, Python's
going to give you an error.
And it's going to
say syntax error,
and it's going to
highlight this line.
And then you're going to know
that there's a mistake there.
And you should be
using equality,
because it doesn't
make sense to be
using-- to assign-- to be making
an assignment inside the if.
So we've learned
about branching.
And we know about conditionals.
Let's try to apply
this to a little game.
And spoiler, we
won't be able to.
We'll have to learn
about a new thing.
But back in the 1980s,
there was the Legend
of Zelda-- cool
graphics-- where there was
a scene with the lost woods.
Oversimplification if
anyone's a Zelda die hard fan.
But the basic idea was
if you entered the woods,
you entered from the
left to the right.
And then as long as
you kept going right,
it would show you the same
screen over and over again.
And the trick was you
just had to go backward,
and then you'd exit the woods.
So very simple.
Using what we know so far, we
could sort of code this up.
And we'd say
something like this.
If the user exits right,
then set the background
to the woods background.
Otherwise, set the background
to the exit background.
Now let's say the user-- and
then in the else, we're done.
Let's say the user went right.
Well, you'd show them
the woods background,
and now ask them again,
where do they want to go?
If they exit right,
set the background
to the woods background.
Otherwise, set the background to
the exit background, and so on.
So you notice that there's
sort of no end to this, right?
How many times-- do you
know how many times the user
might keep going right?
They might be really
persistent, right?
And they'll be like maybe
if I go 1,000 times,
I'll get out of the woods.
Maybe 1,001?
Maybe.
So this would probably
be-- who knows how deep?
These nested ifs.
So we don't know.
So with what we know
so far, we can't really
code this cute little game.
But enter loops.
And specifically, a while loop.
So this code here that could
be infinitely number of nested
if statements deep
can be rewritten
using these three lines.
So we say while the
user exits right,
set the background to
the woods background.
And with a while
loop, it's going
to do what we tell it
to do inside the loop,
and then it's going to
check the condition again,
and then it's
going to do what we
say it should do
inside the code block,
and it's going to check
the condition again.
And then when the condition--
as long as a condition is true,
it's going to keep doing
that little loop there.
And as soon as the
condition becomes false,
it's going to stop
doing the loop
and do whatever's
right after the while.
OK.
So that's basically
how a while loop works.
We have while.
That's the key word.
The condition is
something that gets
evaluated to true or false.
And once again, we have a
code block that's indented,
and it tells Python,
these are the expressions
I want to do as long as
the condition is true.
So the condition is true,
you evaluate every expression
in the code block.
When you reach the end of the
expression-- end of the code
block, you check
the condition again.
If it's true still, you
keep doing the expressions.
Check it again, and so on.
So here's a little game.
And with these lines
of code, we were
able-- we can code up
the lost woods of Zelda.
Even worse graphics, by the
way than the original Zelda
is this one that
I coded up here.
So I print out the
following things.
"You're in the Lost Forest.
Go left or right."
And my program's going to say,
"You're in the Lost Forest.
Go left or right."
It's going to get user input.
It's going to say while the
user keeps typing in right,
show them this text,
and ask them again.
So I'm asking them again by
just saying input here again.
And that's it.
That's going to just keep
getting input from the user.
And if the user doesn't type in
right, and maybe types in left,
you're going to exit out of
this loop, and print out,
"You've got out of
the Lost Forest."
So I have to show you this,
because I spent too much time
on it.
But I decided to improve on
the code that's in the slides.
And I've written here ways that
you guys can also improve it.
So if I run my code--
"You're in the Lost Forest.
Go left or right."
So if I say left, then yay,
I got out of the Lost Forest.
But if I go right,
then I'm stuck, right?
I took down some trees.
You can see there's
no more trees here.
I made a table, and
then I flipped it over.
So the expansion to this
if you want to try it out--
I put this in the comments
here-- is try to use a counter.
If the user types in
right the first two times,
just make that a sad face.
But if the user types
in more than two times,
make them cut down some trees
and build a table and flip it.
That's a cute little
expansion if you
want to test yourself to make
sure you are getting loops.
OK.
So so far, we've used while
loops to ask for user input.
And that's actually somewhere
where it makes sense
to use while loops,
because you don't actually
know how many times the user
is going to type in something.
You can use while loops
to keep sort of a counter
and to write code
that counts something.
If you do that, though,
there's two things
you need to take care of.
The first is the
first line here,
which is sort of an
initialization of this loop
counter.
And the second is
this line here,
which is incrementing
your loop counter.
The reason why the
second one is important
is because-- let's look
at our condition here.
So while n is less than five.
If you didn't have
this line here,
you would never increment n.
So every time through the loop,
you just keep printing zeros.
And you would have
an infinite loop.
I do want to show,
though, what--
if you do have an infinite loop,
it's not the end of the world.
So I can say something like--
so while true, print zero.
So this is going to give me an
infinite loop in my program.
And-- whoop.
OK.
So notice it's just printing the
letter p over and over again.
And if I let it go
any longer, it's
going to slow down the computer.
So I'm going to hit
Control-C or Command-C maybe.
And it's going to stop
the program from printing.
So just in case you ever
enter infinite loops
in your programs, just go to
the console and hit Control-C,
and that's going to
stop it from sort
of slowing down the computer.
OK.
So going back to
this example, I was
saying that if you're using
counters-- variables in order
to sort of count up
inside the while loop,
you have to take
care to initialize
a counter variable first.
And then to increment
it, otherwise you'll
enter an infinite loop.
That feels a little bit tedious.
And so there's a shortcut for
doing that exact same thing.
So these four lines,
you can rewrite those
into these two lines right here
using this new type of loop
called a for loop.
So the for loop says, for some
loop variable-- in this case,
I named it n.
You can name it
whatever you want.
In range 5-- we're
going to come back
to what range means in
a little bit-- print n.
So every time through
the loop, you're
going to print out
what the value of n is.
Range 5 actually
creates internally
a sequence of numbers
starting from 0
and going to that
number 5 minus 1.
So the sequence is going
to be 0, 1, 2, 3, and 4.
The first time through the
loop, you're going to say n
is equal to 0.
Or internally, this
is what happens.
N gets the value of 0.
You're going to print n.
Then you're going to
go back to the top.
N gets the value 1.
Then you're going to go
execute whatever is inside.
So you're going to print 1.
Then you're going
to increment that
to the next value
in the sequence.
You're going to print
out 2, and so on.
So this is the general
look of a for loop.
So we have for some
loop variable-- again,
can be named whatever you
want-- in range some number.
Do a bunch of stuff.
And again, these are part
of this for loop code block.
So you should indent
them to tell Python
that these are the things
that you should do.
So when you're using
range some number,
you start out with variable
getting the value 0.
With variable having
value 0, you're
going to execute all
of these expressions.
After all the expressions
in the code block are done,
you're going to go
on to the next value.
So 1.
You're going to execute
all these expressions
with the variable being
value 1, and then so on
and so on until you go
to some num minus 1.
That-- so using
range in that way
is a little bit constraining,
because you're always
going to get values
starting from 0
and ending at some
num minus 1, whatever
is in the parentheses in range.
Sometimes you might want
to write programs that
maybe start at a custom value.
Don't start at 0.
Maybe they start at 5.
Maybe they start at minus 10.
And sometimes you might
want to write programs
that don't go with-- don't
expect the numbers by 1,
but maybe skip
every other number,
go every two numbers, or every
three numbers, and so on.
So you can customize
range to your needs.
The one thing you do need
to give it is the stop.
So if you give it only one
value in the parentheses
that stands for stop.
And by default, start is
going to have the value 0,
and step is going
to have the value 1.
If you give it two things
in the parentheses,
you're giving it start and stop.
So the first being start,
the second being stop.
And step gets this
value of 1 by default.
And if you give it three
things in the parentheses,
you're giving it start,
stop, and step in that order.
And you're always going to
start at the start value
and stop at-- or so you're going
to start at the start value,
and you're going to
go until stop minus 1.
So those are the
sequences of numbers.
So in this first
code right here,
my sum is going to
get the value 0.
And you're going
to have a for loop.
We're going to start
from 7, because we're
giving it two numbers.
And when you give
it two numbers,
it represents start and
stop with step being 1.
So we're starting at 7.
If step is 1, the
next value is 8.
What's the value after that?
If we're incrementing by 1?
9.
And since we're going
until stop minus 1,
we're not actually
going to pick up on 10.
So this loop variable,
i, the very first time
through the loop is going
to have the value 7.
So my sum is going
to be 0 plus 7.
That's everything that's
inside the code block.
The next time through the
loop, i gets the value 8.
So inside the for
loop, my sum gets
whatever the previous value
was, which was 7, plus 8.
OK.
The next time through
the loop, my sum
get the value 7 plus 8 plus 9.
Obviously, replacing that
with the previous value.
So 15.
Since we're not going through
10, that's where we stop.
And we're going to
print out my sum, which
is going to be the value
of 7 plus 8 plus 9.
Yeah?
OK.
Yeah.
AUDIENCE: [INAUDIBLE]
PROFESSOR: Do they
have to be integers?
That's a great question.
We can try that out.
I'm not actually sure right
off the top of my head.
So you can go on Spider and
say-- let's say in this example
here.
So we can say 7.1, 10.3-- yeah.
So they have to be integers.
OK.
So that's that example.
And let's erase that.
In this particular example,
we have start, stop, and step.
And here, we're going
every other value.
So we're starting at 5.
Tell me what the next
value is supposed to be.
If we're taking every other one.
7, and then 9, and then--
are we doing 11 or not?
Excellent.
Nice.
Yeah.
So we're going to
the end minus 1.
OK.
So it's possible
that sometimes you
write code where you might want
to exit out of the loop early.
You don't want to go
through all of the sequences
of your numbers.
Maybe there's a condition
inside there where you just
want to exit the loop early.
Inside the while
loop, maybe you want
to exit the loop before the
condition becomes false.
So that's where the
break statement comes in.
So the break works like this.
It's going to-- as soon
as Python sees this break
statement, it's
going to say, OK,
I'm going to look at whatever
loop I'm currently in.
I'm not evaluating
any expression
after it that comes
within my loop.
And I'm going to
immediately exit the loop.
So I'm going inside
this while, this while,
I'm evaluating this
one expression,
and I suddenly see a break.
Expression b does
not get evaluated.
And break is going
to immediately
exit out of the innermost
loop that it's in.
So this while loop that
has condition 2, that's
the innermost loop that
the break is found in.
So we're going to exit out
of this inner most loop here.
And we're evaluating
expression c.
And notice, we're
evaluating expression c,
because it's-- expression c is
part of the outer while loop.
It's at the same
level as this one.
And these ones are part
of the inner while loop.
OK.
Last thing I want to
say is just a little bit
of a comparison between
for and while loops.
So when would you
use one or the other.
This might be useful
in your problem sets.
So for loops you
usually use when you
know the number of iterations.
While loops are very useful
when, for example, you're
getting user input, and
user input is unpredictable.
You don't know how
many times they're
going to do a certain task.
For both for and
while loops, you
can end out of the loop
early using the break.
The for loop uses this counter.
It's inherent
inside the for loop.
A while loop you can use a
counter in order-- you can use
a while loop to count things.
But you must initialize the
counter before the while loop.
And you have to remember to
increment it within the loop.
Otherwise, you maybe
lead to an infinite loop.
We've seen as the very
first example of a for loop
that the while--
the for loop could
be rewritten as a while
loop, but the vice versa
is not necessarily true.
And the counterexample to
that is just user input.
So you might not
know how many times
you might do a certain task.
All right.
Great.
That's all for today.
