[SQUEAKING] [RUSTLING] [CLICKING] ANA BELL: So let's
start today's lecture. We're going to be looking
at three different topics. The first is we're going
to look at a new object type called a string. We briefly mentioned
this word last lecture. Then we're going to see
how we can write programs that start to get input from the
user and show the user output. And finally, we're going to
go into writing a little bit more interesting programs
that make decisions based on decisions that we
actually input in the code, so not decision spontaneously
but things that we will code within our programs. But before we go
on to these topics, I just wanted to do
a quick recap of what we learned last lecture,
just to make sure we're all on the same page. So we introduced the
idea of an object. And every object in Python
has a specific type. And the type tells
Python the kinds of things you're allowed
to do with that object. We talked about, once
you have objects, you can actually assign
these objects to variables. And these variables basically
bind a name to the object in memory. With objects, you can
also create expressions by combining objects together. And the expressions
can either be things that we've seen in math,
like with parentheses and with object operator object. Or they can be things
like this, which was introduced in programming. It's an expression, but
it's a different one. It's more like a command. Or I'm asking Python to
do this operation for me. What is the object that comes
back from this operation? So today, I'm going to go over
this little memory diagram we started drawing last lecture. And I'm going to use this
memory diagram today as well. Here's some lines of code
that we wrote last lecture. So we created-- we
wrote a line in Python that created an object. Its value is 3.14,
a float in memory. And the name we gave this
object was pi, so just the name pi, P-I. Radius = 2.2 is another
assignment statement in Python. And it binds the name radius
to the value 2.2 in memory. And once we've created
these variables, we can just invoke their names. We can use their names
to tell Python to grab for me the values from memory. So when Python sees pi times
radius**2, that means take pi, multiply it with
the radius squared. So behind the scenes, Python
goes, grabs the value 3.14 from memory, replaces
pi with that value, grabs 2.2 from memory, replaces
radius with that value, does the operation according
to the precedence rules. And then that
expression, the thing on the right hand side of this
equal sign, becomes a value. That value is then created
as a new object in memory right here. And that object in memory is
then bound to the name area. That's exactly what
this assignment states. And we can do something
like this in Python, which we can't actually do in math. If we did this in
math, the expression would basically say 0 = 1. But in Python, it's totally
fine because again, we evaluate the thing on the right
hand side of the equal sign. So on the right hand
side of the equal sign, we say I want to grab the
value of radius, so 2.2, add 1 to it, 3.2, create
this object in memory, here I have a whole new
object in memory 3.2, and then assign it
to the name radius. So I've lost the binding
from the original 2.2 and rebound the name to 3.2. So we're not modifying
objects in memory. We're creating new
objects in memory whenever we do such operations. We're going to see
how we can modify objects way into the future. And just for completion, when
we have a line that says var = type (5*4), Python also
sees this as an expression. And so as an expression,
it has a value. So the right hand side
of this equal sign says, well, I'm going to
systematically evaluate this and say, what's 5 times 4? It's 20. What's the type of 20? It's an integer. And so that's what the
right hand side evaluates, to an integer. And I'm going to bind that
value, int, to the name var. So var is another variable name. And its value is int,
the type of my object, which is a little strange. So far, we've just put
numbers in our memory. But we can put any
object type in memory. OK, so let's move on a little
bit onto the new object type called a string. So a string is
actually a sequence of case sensitive characters. The characters can be anything. We have lowercase letters,
uppercase letters, the numbers on your keyboard,
the special characters you see on the keyboard. Even the Enter when you
do a new line or a tab has a special character
associated with it. And the way we tell Python
we're creating an object of type string is by enclosing
the characters we want to be part of that
object in these quotation marks. So when Python sees
the quotation mark, it knows you're creating
a string object. So here, I'm creating
the string object which has the lowercase
letter m, lowercase letter e. And here, I'm creating
the string object which has the lowercase y,
lowercase o, and lowercase u letters. And these objects
are things in Python. And we're just
going to give them a handle, a binding with
some more convenient variable names, a and z. So in memory, the way this
would look in our little memory diagram is we would have
the string characters "me" bound to the variable a. So basically what
we've seen before. All right. So now, what are some things
we can do with strings? Well, some really
common operations are that we can
concatenate strings or we can repeat strings. So here, I'm not going
to put the z in memory. You can imagine how
that would look like. But let's say I
create now a variable b equals the letters myself. What if I do a plus operator
between these two strings? The plus operator
tells Python that I'm going to take these two strings,
the individual characters in each string, and
just put them together to make one new
object that is all of these letters put together. So c = a + b is another
assignment operator. And on the right hand side,
we have an expression, plus operator
between two objects. It's going to put me,
which is the c letters, and the myself, the b
letters, all together to create a new object,
which I then give a handle or a binding, c. So from now on, anytime I
want this particular string of characters, myself, I
can just invoke the name c in my program. That's just the variable
name that I gave it. Now, notice it didn't
insert a space. It didn't do me space
myself because we didn't tell it to do a space. So if we wanted to
do a space, we'd have to put it in ourselves. So we can
concatenate-- so we can have a larger expression where
we concatenate a with a space and with b together. So that will give me an
entirely new object in memory, the string me space myself. This new object is
bound to the name d. Is that OK so far? Does that make sense? OK. All right. So that's concatenation. It basically takes these
two string characters, puts them together
in a new object. What about the star? I briefly talked about
this as repeating something last lecture. Well, the star operator works
between a string and a number. It doesn't work between
a string and a string. It doesn't work between
things like that. It works between a
string and a number in either order, so a number
string or a string times number. So here, again, it's
an assignment operator. The right hand side,
we're going to figure out what it evaluates to first. So a times 3 means I'm going to
repeat this particular sequence of characters, me,
because that's what a is, it's me, three times. So this line of
code here is going to create me, me,
me as a new object. And the equal sign tells it
to bind it to the name silly. So any time I want to grab this
particular string of characters from memory, I can just
type in silly in my program and that will automatically
grab that particular sequence of characters from memory. All right. Let's do a quick
exercise to make sure that you all have this. And as you're thinking
about what this does, I can start typing
it in to the console. Or you can either even type
it in to check yourself. So b is going to be colon. And c is going to be
the close parentheses. So if we go here, we have b
is equal to just this colon. And c is equal to the
close parentheses. And we don't have to do
all the operations at once. We can just do
something like 2 times c and figure out what that is. It's just repeating the
close parentheses twice. And then we can
do b plus 2 times c to give us colon close
parenthesis, close parenthesis. So super happy. What about the next one? f is a. g is actually the space b. So there's a space character
in there, a little tricky. And h is 3. Is this the number 3
or the string 3 for h? Yeah, exactly. It's the string 3. So what is f plus g? Again, we can do it in pieces. What is f plus g? a space b, exactly right. a is by itself. And g is space b. What is int h? Yeah, it's just 3. What's the type of 3? int, exactly. I just cast it to an int. So if I have f = a, g = space b,
and h is equal to the string 3, f plus g, we're doing it
a little bit at a time, is a space b. And h is just see
the string 3 here. So if I cast it to an integer,
it gives me just the number 3. And we can wrap each of
these in a type command to see the exact type. But we can tell right away. So if we do f + g
multiplied by int of 3-- or sorry, oops, int of
h, which is just a 3, it's going to repeat
a space b three times. So there's one, there's
two, and there's three. What would have
happened if I forgot to cast it to an integer? What do you think,
if I just did h? An error, yeah, exactly. They're not scary. They're kind of informative
once you get to know them. So it's a type error. Something's wrong
with our types. Can't multiply a
sequence, so an integer-- or a string, a sequence,
by a non-integer. All right. OK. So what are some
other operations we can do with strings? There are some
different things we can do with strings
that we actually haven't seen with numbers
in the last lecture. One of the more
common operations is to get the
length of a string. So this tells us how many
characters are in the string. So if we say s is
equal to abc here, I'm creating a string with
characters a, b, and c, and I'm giving it the name s. Now any time in my
program when I say s, Python will replace that with
this string of characters abc. I can wrap s in this
lean len command. And this len command
is an expression. Basically, Python
reads this, and it evaluates it to one value,
so replaces this expression with one value. How many characters
are in my string? So len s basically
become the number 3. So in my program,
I can say something like another
assignment statement down here, chars
is equal to len s. This is an expression
like in the previous line that evaluates to 3. So basically, this line
says chars is equal to 3. OK. That's a pretty simple
operation with strings. Now we're going to get into a
little bit more detailed ones that requires you to
remember this Python syntax. So one thing we
can do with strings is we can grab
individual characters at different positions. So that's called slicing. The syntax, or the way that
we actually do this in Python, is using square brackets. So you can see this here. We have some square
bracket notation and this is just
how Python does it. So if we have string s is
equal to the characters abc, the way we tell Python
we'd like to extract a character at a
particular position is by indexing into that string. Now, in Python and modern
programming languages, indexing happens from 0. We count from 0 in programming,
in computer science. So what that means is the
index of the first character, the index of a is 0, the index
of b is 1, and the index of c is 2. So we can say, what's the
character at the first position or the first location? But in computer
science speak, we say that's the
character at index 0. The character at index 1 is
the character at location 2 and so on. So when we're indexing
into a string, we're always starting
to count from 0. So s at index 0, that's
how we call this line here. It's another Python expression. It just looks different than the
expressions we've seen so far. But this entire
expression Python evaluates to a particular value. And the value it evaluates it to
is the character at that index. So just to show you what
that looks like in here, if s is equal to abc,
all we would type is this, s at index 0. And this expression evaluates
to that single character, a. s at index 1, b,
s at index 2, c. S at index 3
basically says, what is the character at
the fourth position? Well, abc only has
three positions. So this will actually
give us our second error of the class, an index error. This is a pretty common
error as we start working with more complex programs. It basically means you've
indexed too far into the list, either to the right
or to the left. You can index into a list
with negative indices as well. So if you ever want to grab the
character at the last position, so at the rightmost
place, that's the character at
index negative 1. It's a really convenient way
to grab that last character. You basically ask,
what's s at negative 1? And Python automatically grabs
for us that last character. So we don't have to use an
expression like len of s negative 1. That would be c as well. And here, I've inserted an
expression, len s minus 1, directly in that index. And that's totally fine. Again, Python evaluates things
in to out, left to right. It evaluated len
s minus 1 to be 2. And basically, this
line became what's s at index 2, which
we knew was c. AUDIENCE: So why did it
make negative 1 is c? ANA BELL: Because when you
index into negative numbers, we start counting from
the right hand side, just Python convention. And so s at negative
4 will give us an error as well,
because now we're indexing too far to the left. There's nothing there. OK. So we can index to
get single characters. That's fine. We just use square
brackets and say the index that we'd like to
get the character at. We can also slice
to get substrings. So instead of getting
single characters, we can ask Python to
get us a substring starting from one index,
going up to some other index, and potentially
skipping characters. You can take every
character along the way. You can skip every other
character or some other pattern like that. The syntax for that
is similar to slicing to get a single character,
slightly different, though. It's similar in that we have
square brackets involved. Slightly different
because now we have to give three numbers
within those square brackets separated by colons. The first number will represent,
what's the start index? So where do you want to
start your substring from? The second is, what's
the stop index? So we're going to take every
character from that start index, going all the way up
to but not including the stop. And the step means, how
many characters do we skip? So if the step is 1, we're
taking every character. If the step is 2, we'll
take every other character. If the step is 3, we skip
every two characters and so on. Now, there's a bunch
of combinations we can do with
these three numbers within the square
brackets that, as you work with these exercises,
you'll get the hang of. For now, it won't
hurt to always give it a start, a stop, and a step. That's perfectly fine. But something that's really
common, if you're always going to take every
single character, is to just omit the step part. So if you just give it two
numbers, number, colon, number, Python automatically knows that
your step will be 1 by default. So you're not skipping anything. If you're just giving it
one number, no colons, we're back to the previous
slide, where we're just grabbing one element. And I know this is going
to be a little confusing. We're going to look at an
example on the next slide. But this is
something you'll just have to practice a
little bit in the shell with the following
example, hopefully, just when you go home, just to
make sure that you understand what it's doing. If you have a
question, like what if I put in this
number or this number? just put it in the shell
and see what happens. So let's take a look at
a couple of examples. So how do we slice
to get substrings? Let's say our string is
this longer thing, abcdefgh. When we slice, the first thing
we want to look at is the step. Is it positive or negative? If it's positive-- and remember,
if you omit it by default, it's plus 1. So if it's positive, we're going
to work our way left to right, the way we read. If it's negative, we're going
to work our way right to left. So what if we index
s from 3, colon, 6? The step is positive
1, so we're going to work our way left to right. So that means we're going
to start at index 3, so that's the d. So we're going to grab the D
and we're going to go up to-- get the substring from d up to
but not including the character at index 6, the h-- the g. Sorry, the g. So the characters
we're going to grab are the d, the e, and the f. We start at 3, we go up
to but not including 6, taking every character
because the step is 1. What if the step was 2? So same thing as we just
did, except the step is 2. Again, the step is
positive, so we're going to work our way left to right. We're going to start at index
3, so we're going to grab the d and we're going to create
a new object, which is going to be the characters d. We're going to skip the
e because the step is 2. Take the f, and that's it. We've worked our way up
to, but not including the element at index 6. There are some other things-- I guess tricks
are-- you might want to call them that you can do. So if we just put
an empty colon here, that says just make
the same object again. So that will evaluate
to just abcdefgh again. If we do colon,
colon, negative 1, this is shorthand
notation for basically grabbing for me the string
backward, so hgfedcba. Just make the same string as
the original one, but backward. And we can do something
like this for 1 with a step negative 2. Now the step is negative. So that means we're going to
work our way right to left. We're going to start at index 4. So we're going to
grab the e, we're going to skip every
other character. So we're not going to take
the d, but we will take the c, and we're going to go down to,
but not including the character at index 1. So we're going to
stop right here. So the characters we took in
this order were e and then c. So this entire expression
evaluates to ec. Yes, question? AUDIENCE: Why did you skip d? ANA BELL: Why do we skip d? Because the step is 2. So when the step is 1,
we take every character. If the step is 2,
skip every other one. Yeah? AUDIENCE: For the first one, s
3 to 6, why is g not included? ANA BELL: g is not included
just by definition. We go up to but not
including the stop. So we'll go up to, but not
including the character at index 6. That's just the definition
of slicing in Python. AUDIENCE: Like a
character that starts up to and including stop
minus 1 [INAUDIBLE].. ANA BELL: So up to and
including stop minus 1 means we go up to
and including 5. Right, yeah, exactly. Yep. OK. So again, if you're unsure
of what a command does, always try-- you can always try
it in your console, the shell, and here's an
opportunity to do that. So here's a string s,
ABC d3f, and I'm actually going to write this one down. Just ABC, space-- there's
a space here, 3d-- what do I do? Oh, d3f. And then another space, and ghi. So what do you guys think
the first one will be? 3, colon, len s minus 1. I'll even do the
indices here for you. What's the start? Yeah, the space, exactly. So it's going to
be a little space. What is len minus 1? AUDIENCE: That's
the length, right? It's not [INAUDIBLE]. ANA BELL: Yeah, what's the
length-- how many characters are in here? 11, yep. And minus 1 is 10. So when we do this--
when the stop is 10, that means we're
going to go up to, but not including
the character at 10. So we're going to
go up to this h. So we're going to take
the space, d3f, space gh, and we stop. Yeah. AUDIENCE: Why do we start
the next thing at 0 again? It's just-- ANA BELL: Convention. AUDIENCE: OK. ANA BELL: Computer science. Programming. Except for MATLAB, I think
they still start indexing at 1. Other questions about this one? Is that all right? OK, how about the next one? s
4, colon, 0, colon, negative 1. What's the element at index 4? The d, yep. So we're going to grab the d. Are we working our way
right or-- to the right or to the left? AUDIENCE: Left. ANA BELL: Yeah, exactly. So we're going to go up to,
but not including the character at index 0. So we're going to get the d,
the space, the c, the B. Am I taking the a? No, exactly. So that's it. D, space, CB. Yes? AUDIENCE: If we want
to include the A, would the second
value be negative 1? ANA BELL: If you did
want to include the A, actually, you would want to do
something different, I think. You can't go to negative
1 because negative 1 is actually this right here. That's a good question. I'd have to try it out,
play around with it. But if you want to include
it, I think maybe you would just do an empty-- sorry, go ahead. You would just probably
do an empty colon, and by default, that means
the beginning and the end. But I'd have to
try it out, yeah. How about the last one? 6, colon, 3. What's the element at index 6? The empty colon work-- OK, perfect. Thanks for trying it out. The empty colon works, yeah. If you wanted to grab B.
All right, so s 6, colon, 3, what's the element at index 6? AUDIENCE: The F. ANA BELL: The F. OK, great. And we're working our way
to the right or to the left? To the right. OK. So we're going to start here,
but we need to go this way. But what's the stop index? Yeah. It's not there, it's behind us. So this last one is
actually an empty string. And I'll even-- we can even-- we
can try it with something else, too. So if we have this ABC-- if I'm indexing starting from
2 and I'm going backward to 0, then that gives me
the empty string. And the empty string is just
quote, quote with nothing inside. So that means we didn't
take any characters in that particular case. Is that all right? AUDIENCE: Is it valid? ANA BELL: It's valid. We just-- there are no
characters in between the f and behind the f. Yeah. OK, so I'll mention the strings
are actually immutable objects. And really, a lot of the
objects we've seen so far are immutable. That means they can't be
modified once they're created. We've seen this already. When I draw the
memory diagrams, when I create a new object, which is,
for example, what's the string version of this integer or
when I cast a float to an int, things like that, I'm not
changing those original objects I've created, I'm just making
a new green box in my memory and reassigning the name. And we're going to see later
on in this course mutable objects, which means that once
you create them in memory, you can modify them, but
for now, any time you make a change to
such an object, well, you can't change the object. If you want to get a different
version of the object, Python will create a
new object in memory and you can reassign the
variable to that new object. So in this example,
if I want to grab-- if I have the string
car in memory like this and it's bound to
variable s and I want to change the first letter
to a b, I'm not allowed to. Python won't let me do
something like, I want to change the letter at index 0 to a b. That's not allowed. You can get new versions
of that particular string. So you can do some
random expression to create the bar
that you might want. But then the car
remains in memory. So the car will still
be there, we're just losing the binding from it. So any questions so
far on these strings? Mostly they're new data type. You haven't worked with them
like you have with numbers, so it's a little bit different. Again, someone had a question. How do you get the A? Backward. Try it out in the console. I'm happy to answer questions,
help you try it-- try it along with you, but that's what
the console is there for. The shell. Here, that's what
it's there for. It's just to try
quick little things if you ever have a question,
what if this or this and you get to try it out? Now let's move on to
some input/output. So far, the programs that we
can write are pretty stagnant. There isn't much
interesting things that we can do with them. There's no interaction
with the user. So so far, when we've tried
to output things, well, you might think, we have
been outputting things. So when we write in our console
something like 3 plus 2, Python does show
something in the shell. This is maybe how we
interact with the user. But this is not
actual true output. This is-- I call this
peeking into the value of the expression. But if you were to
write some expression like this in a
file editor, Python wouldn't actually print it out. And so here's all the things
that we've already tried today. We've created all these strings,
we've got the length of s, we indexed. Anytime we typed these
expressions in the shell, Python automatically
gave us our value. But if I were to type those
exact expressions in a file editor on the left here,
Python is not actually going to print these out. So this is the file editor. From now on, we're just
going to work with files. I'm going to run it by hitting
this little green Run button or hitting F5. Something happened in the shell. My program ran. It says here, it ran this file. But there's no output. Where was the length of s? Where were all these
indices we've done before? And that's because these
aren't actual outputs. When we type them
into the shell, that was just us doing
quick little expressions in the shell giving us-- that's why I call it
peeking into the value because it's not true output. If you want the
user to see output and the shell is how we're
going to show the user output from running a file, we
have to explicitly tell Python, hey, I want you to show the
output from this expression, or I want you to show the
output from this command. And we do this using
the print command. So if we take our
expression that we want to show the output from
and wrap it in a print command, Python will then show that
output and only that output. Can you imagine if
we wrote a file that did all these operations and
all these intermediary outputs were being shown? That would lead to a
really messy file-- or a messy program. And so that's why we
have a command where you can explicitly tell
Python just the things you want to show to the user. So here, if you want to
print the length of s, we can wrap the length
of in a print statement and then run the file. And now, the only thing
that gets shown to the user is the thing I explicitly
printed out, the 3. And then down here, if I want
to print this other result-- the result of this
other expression, I can wrap that around a print
statement and Python will then print that one as well. But now I'm in charge of showing
the user the things that I want to show them. OK. So whenever you have
a print statement, Python will print that
resulting expression and then enter a new line. So as you saw here, we had
two print statements one, around len and one
around s at negative 3. And Python put the result of
these expressions, each one on a different line. Sometimes you might want to have
expressions on the same line-- or the results of expressions
all on the same line. So we can do that. We can put all of
these different objects within the same print statement. We separate them by a comma
within the print statement. That's down here. Python will print
all of our objects no matter what type they
are, and it will separate each object by a space. So there's my object "the,"
there's my object the number 3; and there's my object
the string "musketeers" and it printed it all
on one line with a space in between them. And that's what this comma
does, it automatically inserts the space. Now let's say you don't want
a space for whatever reason. What if we try concatenating
these objects together? Remember, we saw
concatenation, we said it doesn't
automatically insert spaces, it just merges the
strings together. And we run it? Well, I already gave it away. It's going to be an error,
but let's see the error. It's a type error. It says can only concatenate
strings, not integers to strings. All right, makes sense. This is a string, this is not
a string, so that's not OK, and this is a string. So instead of concatenating
different objects together, we now have to remember to
cast every object that's not a string to a string. So this line is exactly the
same as the previous one except that b, which was
the number the integer 3, is now being cast to a string. So I'm wrapping the
b around the str. And that casts my
integer to the string, and now Python is
happy to concatenate these three strings for me. OK that's basically what I said. So that's output using
the print statement. Now how about input? We can get input from the
user, not surprisingly, with a command called input. The format of input
is usually like this. So we have the input command. In the parentheses,
we give it a string. And then we usually want to
save the input to a variable. So the next few slides are
going to go through step by step what happens when I
have these two lines of code. Text equals input "Type
anything," and then I'm going to print 5 times text. So when Python sees a line
that says input and then some string, Python will
automatically take the string within the input-- so in this particular case,
here's my input command. The string inside the input is
"Type anything," colon, space. On the shell, Python will
put that string for you. And then it will wait. It waits for the user to type
some stuff in and hit Enter. As soon as the user hits Enter,
whatever the user typed in-- so let's say the user
typed in "howdy." Whatever the user
types in, will be saved as a string replacing
this input statement. So you can think of the
input like an expression. It's a weird one because
it's waiting for the user to give us something. But in the end, the input gets
replaced by the string version of whatever the user typed in. So the user can
type in something-- numbers, letters,
characters, anything. As soon as the user hits Enter,
whatever the user typed in will be saved as a string
replacing this input. So in memory, the way
this looks like is-- this is our memory cloud. Here is this-- here is this
object that I've created, which is the exact
characters the user typed in. OK, well, if the user
typed in "howdy," then what does this line end up? Being text is equal
to the string "howdy." And that basically is What we've
seen on the previous two slides when we've worked with strings. We're going to
assign this variable and bind it to this particular
string of characters. Now the next line is easy. We're going to print whatever
the result of repeating text is five times. So the print will
show on the shell, howdyhowdyhowdyhowdyhowdy. Whatever the user
typed in five times. OK. Let's look at another example. In this particular
one, we're going to ask the user for a number. And I want to print 5 times
whatever the user types in. So num1 will, again, grab input. So what we're asking the user
to do is to type in a number. So when the Python sees this,
it prints "Type a number" and then waits for user input. Let's say the user
types in the number 3. That gets saved as the string 3. Again, so no matter
what the user types in, it's being saved as a string. Even if it's a
number, it's being saved as a string that number. So to Python, it's a character. To us, it's a number, but to
Python, it's still a character. So num1 in memory basically
becomes the string 3, just one single character 3. When I print 5 times num1, what
is that going to look like? You guys tell me. AUDIENCE: 33333. ANA BELL: Exactly. Right. 33333. Because we're working with a
string here, not an integer. If we want to work
with an integer, we have to wrap
our input statement with a cast statement. So again, this is
what Python does. We can combine
expressions together. In this particular
case, we're going to combine the
casting, the input, with the input statement. So now the user can
type in for me 3 again. The input itself is
going to be the string 3, but that line
becomes num2 equals int, parentheses, string 3. And that-- I did it on
the shell earlier today. When we cast a number--
a string to an int, it becomes the number, that int. So num2 is then going to be 3. In memory, num2 is not
the string 3 anymore because we've cast it to 3. So when we print
5 times 3, we're doing the mathematical
operation 5 times 3, 15. OK. Let's have you code. So I'm going to give
you a couple of minutes. I'm going to have you write a
program that is interactive. So it's going to ask
the user for something and it's going to print
something back to the user. So we're going to ask
the user for a verb, and then I want you to
print two things for me. The first is whatever the
verb that user typed in, you're going to write "I can
whatever better than you" on one line. And then on the next line-- so
with another print statement, I want you to print
that verb five times. So if the user types in
"run," you're going to write "I can run better than you." And then on the next
line, run run run run run. So the way these You Try
Its work is I actually have some space here. I've already pre-written
instructions for you. And all you have to do
is fill in the code. So I'll give you a
couple of minutes and then we'll write it together
with suggestions from you and we'll see how far we can
get, and we'll definitely-- we'll definitely
finish it together so you don't have to
finish it on your own. Yeah? AUDIENCE: It this supposed
to have [INAUDIBLE]?? ANA BELL: You should
have this file. It's part of the zip file
you downloaded for today. AUDIENCE: How do
I-- oh, here it is. ANA BELL: Yeah. All right, does anyone
have a start for me? So how can I ask
the user for input? Yeah? AUDIENCE: I think the
question was [INAUDIBLE].. ANA BELL: Yep. That works for me. And I'm adding a little extra
space here between the colon or whatever prompt you have just
so that when the user types it in, it isn't right
beside the colon or the end of this string. So as soon as we do
this, the user will-- the program will wait, and the
user will get to type something in. What's the next step? What's the first-- how can you
how can you use this input? AUDIENCE: Do print. ANA BELL: Yep. Let's print something. "I can" in quotes. Yep, "I can." AUDIENCE: Could you, like,
outside of the quotes, put the question
within [INAUDIBLE]?? ANA BELL: Yep. We can put a question. Yep, exactly. "I can," question, comma,
because it's another object, and I'm happy to put
a space in between it. "I can," question, another
string, "better than you." Whoops. OK. There. And we don't need to write
the full program right away. We can just test
this little bit out. So choose a verb run. The one I gave you is fine. That looks good so far. All right. So then we can keep
working on the second part. How can I print that
verb five times? Yeah? AUDIENCE: Print and
then question times 5. ANA BELL: Print
question times 5. OK, let's run it and
see what happens. Run. Not quite. I'm missing spaces, but
this is an awesome start. How can I add the
spaces in there? Yeah? AUDIENCE: Parentheses, then
verb plus, like, quotes with a space. ANA BELL: In parentheses, yep. We can concatenate
it with a space. Exactly. All of that times 5. Yeah, let's try that. Run. Yep. That looks pretty good. I do want to mention one thing. There is one improvement we
can make to this program. If we look at the
output here, the thing that we're actually printing
out is this verb space. There's 1, 2, 3,
4-- and the last one actually prints it with
a space at the end. So a challenge for you, and the
answer is a little bit lower-- I provide you guys with
the answers to these, but a challenge for
you is think about how you can change it-- change
this last print statement so that this last run doesn't
actually have that extra space. Just think about it. You don't have to
do it right now. OK. So with what we know
so far, we can actually apply some of these ideas
to a more numerical example. So Newton's method is
a way to actually grab the roots of a
polynomial numerically using this idea called
successive approximation. We can't actually write
the full algorithm with what we know so
far, but we can write a really important part of it. The part is-- the
part that we can write is the one that
gets a next guess based on an initial guess. So you don't need to understand
how the algorithm works, but basically, the next guess
based on an original guess looks like this. This is the formula. So the next guess is the
original guess minus-- and we evaluate the
formula for whatever polynomial we want to find
at the original guess divided by the derivative of that
function at the same guess. So here's just some code we've
got asking the user for input. What x do we want to
find the cube root of? Then we ask the user
for input, what guess do you want to start with? And then we can just print
the current estimate cubed. So we just guess cubed. And then the next guess is just
following the formula up here. The next guess is going to
say it's my original guess. So the g that I read
in from the student-- or from the input minus,
and now I have a division. The top of it is
going to be f at g. And the computer is
not evaluating f. We have to give-- we have
to actually write down what the formula is-- the function is. We want to evaluate at g,
so it's g cubed minus x. That's our function up there. Divided by the derivative. And again, the
program is not going to evaluate the
derivative automatically. We're going to tell it what
the derivative is manually. So the derivative of g cubed
minus x is just 3g squared, so then we just
hard code that in. And the next guest
to try is just going to be that particular
division and subtraction. AUDIENCE: Is this a
function of the derivative? ANA BELL: I'm sorry? AUDIENCE: Sorry. Is this a function for the
derivative of [INAUDIBLE]?? ANA BELL: There are
Python packages that allow you to do that,
but for our purposes, we're just going to hard code
it in this case, but yeah. So the way this looks
in code is as follows. That's exactly what
we had in there. And if we run this
program, all it does is-- let's say we want to
find the cube root of, say, 27, let's start with,
I don't know, 5. It tells me that 5 cubed is
125, way too big, obviously. So the next guest
to try is 3.69. And that's all the program does. It doesn't take this next
guess and do another guess. We haven't learned how
to do such a thing yet, but we will in the next
couple of lectures. One other thing
I want to mention is this thing
called an f-string. It's something that
became available I think a couple of years ago
in Python with Python 3.6. It's a way more
convenient way for us to print out mixtures of literal
text and resulting expressions. So if you have a bunch of
complicated expressions you want to print
out, an f-string is the way to do it these days. What we know is these
first two lines. This is what we've learned
in the past couple of slides. So if you wanted to
have these two values and print this big number is
whatever fraction percent out of the original number, if you
actually run this in the Python file, you'll see
that this comma here puts an extra space between
my number and the percent. And that doesn't look very good. When you have 3%, you're
expecting the percent sign to be right by the 3. But this comma adds
for me an extra space, so it looks a little bit weird. Which means that our solution
was to cast things to strings. So if we wanted to have
that percent sign be right beside the number, we'd
concatenate this cast with the percent. But f-strings allow us
to do this all in one. So there's no concatenation to
think about, there's no casting to think about. f-strings basically are this
f and then a long string. And it's a mixture of
expressions and things that I want to print
literally to the screen. So the thing that's not
inside a curly bracket are all things I'm going to
print literally to the screen. So the space is space, and
then later on, percent, space, "of percent," those are all
things that will literally be printed to the screen. Anything that's
within a curly bracket is considered an
expression in Python. And so before Python prints
out the thing to the screen, it's actually going to evaluate
whatever num times fraction is, and it knows these are
going to be variables. And then later on, fraction
times 100, and then later on, none. These are all variables
or expressions that it will evaluate
before actually putting them on the screen. And now notice,
these expressions, we might have had to cast
to strings beforehand if we wanted to
concatenate them, but now we don't because
they're in this special format with the curly brackets
of the f-string. So just something to practice. I'll interchange-- I'll
use sometimes this, I'll use sometimes casting,
I'll use sometimes f-strings, but if you can use
f-strings whenever you can, that's really the way to
go in Python these days. So the big idea, actually,
even with f-strings, is that you can place
expressions anywhere. We saw-- we placed expression-- I forget here-- where
we indexed-- we placed an expression in the index. Now we're placing expressions
inside print statements. And now we're placing
expressions inside f-strings. So expressions can be
placed really anywhere, which is pretty awesome. Very versatile. Python will just
evaluate them and then just move on to the next lines. OK. So the last topic-- I'm sorry. Any other questions about
the inputs and outputs? Is that all right? OK. So the last thing that
we'll talk about today-- and we will maybe
talk a little bit about it next time, is
conditions for branching. So right now, the kinds
of programs we can write are basically very linear. We have a bunch of
lines of code and they get evaluated one by one. There's no way to
skip around, there's no way to repeat things,
there's no decision points in the programs. The values that you
get are just the values that are in the program. Now we're going to look
at ways that we can add decision points in our program. So if some value-- if some variable value is less
than some other variable value, we want to evaluate some code. And otherwise, we'll
do some other code. So some code can now be skipped
in programs with this new-- with this new idea. Before we go on to showing
you exactly how to do that, I'm going to talk about another
notion of equal in programming, and this might be more
the notion of equal you might be used to in math. So the first notion of equal
is the one we've already seen. It's assignment. It's done with one equal sign. The value on the
right-hand side is bound to the variable
on the left-hand side. That we've known. Double equal in Python
is how we tell Python that we'd like to know whether
these two expressions are equal-- or equivalent. Sorry, not equal. So if we're going to be
looking at equivalency, how do we express equivalency? Well, if something is
equal to something else, we can say yes or no. We can say true or false. True or false
should ring a bell. It's the Boolean data type
that we saw last lecture. And so now that
we're going to show you equality or
conditionals in programming, we're going to start talking
about Booleans a little bit more. So expressions don't just
have to be numerical. Expressions can actually
give us Boolean results. So for example, an
expression like 2 less than 3 is OK in Python, and
this expression actually evaluates to a certain value. It's not a number,
it evaluates to true, the Boolean value true,
because, yes, 2 is less than 3. The equal sign here, this
notion with a double equal, is how we ask Python to tell
us whether two things are equivalent. And this will be the
Boolean value false. So here's a bunch
of other operators that we can run on any
type, really, in Python. Most of them-- most
of the time we're going to run them
on numbers, but they can be run on strings and
things like that as well. So obviously the double equal
sign checks for equality. So if i is the same as
j, this entire expression is replaced with true. And if they're not equivalent,
this entire expression is replaced with false. If we want to check
for inequality, we use not equal-- so
exclamation mark equal is-- it means not equal. So if the number-- or whatever object i is
not equal to object j, then this entire
expression is true. If they are equal, then the
entire expression is false. And then of course, we've
got the less than, less than or equal to, greater,
greater than, or equal to to work with as well. We can apply these to strings. And with strings, it's important
to be careful about case. So for example, lower case
a equivalent to upper case A is false because they
are not the same character. Now that we're talking
about Boolean operators, we can actually start to
combine them together. So if I have the expression,
for example, 2 less than 3, like I wrote on the
board, that's true. But I can combine that
expression with another one. Actually by itself, I can say,
what is not 2 less than 3? And that will be false. It's the opposite of it. But I can also combine
Boolean expressions together. So I can say, what's 2 less
than 3 and 3 less than 4? So 2 less than 3 is true. And 3 less than 4 is also true. So the combination of
these two expressions-- of these two Boolean expressions
is what is true and true? True. So if one is true and
the other one is true, then both of them--
and both of them together are going to be true. If one of these is false-- so is 3 greater than 4 is false,
well, what's false and true is going to be false. So if one of these
operators is false, then the entire
expression is false. And you don't have to
remember this truth table. You can always
check it like I just did right here in the console. But at a high level, when
we're doing the "and" operator between two Boolean expressions,
we need both of the expressions to be true for the
result "and" to be true. The "or" is the other
one we usually-- we can usually do. The "or" is always true except
for when both of the operators are false. And it makes sense makes
sense in English to write. If either operator is true,
then the entire result is true. But when both are false,
the "or" of both of them is false as well. So here's a little
example where we can use these operators in Python. So we can draw the little
memory diagram as well. So pset_time is 15, there's
my variable. sleep_time is 8, there's my other variable. I'm going to print sleep_time
is greater than pset_time. So here, my print
statement is going to grab that expression,
which evaluates to false. 8 is less than 15 is false, so
that's going to print false. And then I have
two more variables. These ones just
happen to be Booleans. derive is true, drink is
false, so drink and derive is going to be false because
one of them is false. And so here, I've got
this other variable both, and then I'm going to
print false to the console. OK. Quick You Try It for you guys. So let's have you write
a program that saves a secret number in a variable. So that's going to be
your program's secret. Presumably people
using your program won't be looking at
the program itself, they'll just be interacting
with the program in the shell. So save a secret
number in a variable, ask the user to guess a
number, and then print either true or false. If it's the same as
your secret or not. So it's here in this
You Try It down here. So you can start with
something like secret equals and then put your favorite
number there, 5 whatever, and then write the
rest of the code. So ask the user
to guess a number, print a Boolean depending
on whether the guess equals this secret or not. So I'll give you a couple
of minutes to write that. Yeah? Sorry. AUDIENCE: Do you put the symbol
"and" similar to [INAUDIBLE]?? ANA BELL: If you use a symbol
"and," it's not the same. You have to actually
type out A-N-D in Python. The "and" means something else. It's an operator with
the bits of the number. So something-- it's not going
to give the same answers. Yeah. Right, you're thinking about
Java or C++ or something, right? Yeah. All right. Does anyone have a start
for me for this program? How do I grab the user input? guess equals input? AUDIENCE: [INAUDIBLE] ANA BELL: Yeah. We can be nice. "Please guess--" AUDIENCE: [INAUDIBLE] ANA BELL: What's that? AUDIENCE: [INAUDIBLE] ANA BELL: We want
the user to give us an integer-- yeah, a number. Exactly. So-- OK, yeah. If we leave it like that, then
we're just grabbing the string. So we have to cast
it to an integer. Exactly. Now what? How do I check for
equivalency between my secret and the guess? AUDIENCE: [INAUDIBLE] ANA BELL: secret
equal-equal guess. And you want to-- print this, yeah. Let's print that. OK. Run it. Let's guess something
that's not the same. False. Run it again. Let's guess something
that's the same, true. And we can guess something
that's lower to just-- is everyone-- yeah? AUDIENCE: Do you assign-- like for different
[INAUDIBLE],, did you assign the [INAUDIBLE] equal
to guess to a container? ANA BELL: Yep. Yep, exactly. Equal equals this thing. Yep, and then you can do
whatever you want with that. Print equal or something. That's the same, but yeah,
you can do other things with this variable. Yeah. Exactly. 5. Yeah. If you want, at
home, try to see what would have happened if you
didn't cast it to an integer. See if the program
would have crashed or not, or if it would
have just worked but given a wrong answer. So why do we do Booleans? Booleans are important
variables because they allow us to start
thinking about writing programs that make decisions. The way we talk is
we can say something like, if this is true, do
this; otherwise, do this. The Boolean part is if
that something is true. So the something
is true is going to be the Boolean that we
can create in our programs, and then the do this is
some sort of command, and then the otherwise
do that is going to be some other set of commands. So a really simple
Boolean expression could be, it's midnight,
you get a free food email, do you go get the free
food or do you sleep? That's the very simplest
decision point you can make. But with conditionals,
you can actually write a pretty cool program
that gets you to that free food. So let's say this is a map of
MIT, this is where you are, that's where the free food is. We can write a really
simple algorithm using just conditionals that
takes you to that free food. So the algorithm goes like this. So I'm going to say,
I'm going to walk always in this direction. So I'm either going forward,
backward, left, and right, I'm not turning. And I'm going to say
the algorithm is always going to have my right
hand be on a wall. So if the right is
clear-- so standing here, my right is clear,
so I'm just going to keep swimming
until I reach a wall. If my right is blocked
but my forward is clear, I'm going to keep
going like this all the way to the end of the room. If my right is
blocked and my forward is blocked as if I would have
reached the end of the room, I would have gone to the left. And if my right,
forward, and left is blocked, if I'm over
there, I would go backward. So I'd go backward. So basically starting
from here, I've made my way all the
way around this room and I would go out the
door down the hallway. And if the map of MIT
doesn't have islands-- so if the free food
isn't somewhere in an island in the
middle here, if it's just a regular old maze,
I would eventually make my way to the free food
following this really simple conditional algorithm. So how do we actually do
conditionals in Python? How do we tell Python,
hey, I want to create-- I want to insert a
decision point right here? We do that using
the keyword "if." And the "if" starts
a decision block. Now the simplest decision
block is just an if by itself. So if Python sees that if--
so there's some code that it's following, and then at some
point, it reaches the if, the condition tells
Python to check whether that condition is true. If the condition is true-- so
this is our decision point, then I'm going to deviate
from my main program and potentially-- and
do the code that's part of that condition. Those, I guess, two lines,
dot-dot-dot inside there. If the condition is not false,
I'm not going to go that route and I'll just keep following
the rest of the main program. How does Python know how
many code lines to execute that's part of that condition? Well, it looks at
the indentation. So notice here, I've put a
few spaces, for these two dot-dot-dot code blocks here. Anything that's indented
right after that if statement and that colon there
is a set of commands that are part of that block. So anything here will
get executed all at once. And that's a really simple if. Either you do the
set of commands, extra commands if the condition
is true, or you don't. Now you can add an
exception to that. So if the condition is true-- again, we're
following the program, we reached this if
conditional here. If the condition is
true, again, we're going to deviate
from the program and execute this other set
of commands right here. Otherwise, the
condition is not true and we're going to execute
this other set of commands over here. So these guys over here. So either we do
this set of commands or the other set of commands,
but we never do both and we never skip both of them. So either we do one
set or the other. When we're done executing
all the indented blocks, part of the condition
or the other one that if the condition
wasn't true, then we rejoin the rest of the
program and continue executing. So this is all the
rest of the program is at the same indentation level
as our original if and else. We can add a whole
bunch of conditions. Not just an if, do
this, otherwise do this. We can actually add
a bunch of things to check using elif,
which basically stands for else, if
another condition, do this. So here's our program. We reach a decision point. If the condition is
true like before, we'll execute this set of commands,
but otherwise, the condition is not true, we're going to
check another condition. Else, if this other
condition is true, we'll execute this
other set of commands. Otherwise, here's another elif. We'll check another condition. If it's true, we'll execute
some other set of commands, otherwise there
can be more elifs. And at some point,
we're going to rejoin the rest of the program. Now these elifs are going
to be-- each condition is checked one at a time. The very first one that's true
is the one that gets executed. So we're never going to
execute more than one because this is an if,
else if, else if, else if. So even in English, you're
only going to do one of these. You're never going
to do all of them. It is possible to
skip all of them, though, because if none of
those conditions are true, you just don't do any of them. If more than one is true, you
do the first one that is true. If you want to have a
catch-all, a version of the middle if,
elif, elif, you just add an else at the end. So if none of those
conditions are true, you can add an else,
which says you just do this if nothing is true. I like what we had over here. If this one, otherwise do this. Well, if any of these conditions
are true, do one of them, otherwise do this. So here's an example. We've got pset_time, we'll just
put some variables in there. sleep_time, we'll put
some variables in there and run it, see what we get. I've got one code block here,
an if, elif, and an else. So the first code
block, the condition is, it checks that the sum of
those two is greater than 24 and it does something. This is the block that's
part of that condition. Notice, it's indented
by usually four spaces. Elif-- so if this
one was not true, then I'm going to go ahead
and check the next one. The next condition
is that the addition is greater than or equal
to 24, and then we're going to do this
print statement here. And if neither of
those are true, I'm going to do whatever
is in this code block here. I'm going to do these two lines. So this is my-- I call it a catch-all because
none of those other conditions were true, so we're going to
catch ourselves and do this-- do these commands here. And otherwise, once
we finish doing either this one or this one or
catching whatever is left over in here, we're going to evaluate
the print statement here and we're going to
print "end of day" because this is the
rest of my program. Notice, it's at the
same indentation level as my original program. So here is this-- oops, this program. So if pset_time and
sleep_time is 22 and 8, the addition is more than 24. So this is going to enter
this code block here and print impossible. If it's exactly equal to 24-- so 22 and 2, we're not
going to enter this one, but we will enter this one right
because it's exactly equal to, it's not greater
than, so then we're going to print full
schedule and then rejoin the rest of the program
here and print "end of day." And otherwise, if this is
something low, less than 24 and not equal to 24-- so neither of these
conditions are true, then we're going
to enter the else. And we're going to evaluate--
or run these two lines of code here. So the two lines
of code here are going to grab the
absolute value of 24 minus the pset_time minus
the sleep_time figuring out how much time we
have left in the day. It's also going to print this
line here and then rejoin the rest of the program
to print "end of day." OK. Quick check. Nothing to run-- nothing to
write here, nothing to run. Think about this program. What is wrong with it? So I'm grabbing a number
for x, a number for y, and then I'm checking
if x is the same as y, I'm printing x is the same as y. So if I give it 5
and 5, I'm going to print 5 is the same as 5. And then I'd also like
to print these are equal. What's the problem
with this program? Yeah? AUDIENCE: If x is
not equal to y, it's still going to print these
are equal because it's not [INAUDIBLE]. ANA BELL: Exactly. If x is not the same as y, we
rejoin the rest of the program because the indentation
level of this print statement is the same as the
rest of our program. So how do we fix it? Indent. Yeah. We'll just indent that
print statement in to be at the same level
as the if statement. So we can actually nest
indentation statements-- we can nest conditionals
because once we've created a conditional,
it's just a code block. So here, I've got
an if statement with its own code block. And inside that code
block, I can actually have more if statements
that are just going to be executed whenever
this condition is true. So this is the
inside code block. So for example,
the place where we would execute this
inner code block is when x and y are
equivalent because then I'm going to enter this code
block here, this is true. I'm going to print
x and y are equal. And then this second conditional
here, y is not equal to 0, is also true. And then I'm going to
print this one as well. I've already done one
of the conditionals. They're true, so I'm
going to skip the elif, I'm going to skip
the else, and I'm going to rejoin the
rest of the program. All the other cases,
when one value is different than the other,
will either take me here in the else and then rejoin
the rest of the program, or when they're
equivalent, I'm going-- or here, I don't have-- I don't actually have a case
for that one on the slides. But when they're equivalent
and y is equal to 0, I'm not actually going to
enter this inner conditional because y-- while x and y were true-- were equivalent, which is
true, y was equal to 0, so that not equal to 0 is false. It's just backward. And then we rejoin the
rest of the program. Yeah? AUDIENCE: What did you
do to float [INAUDIBLE]?? ANA BELL: Oh. I'm casting the
numbers to floats. I could cast them
to ints as well. Yeah. Yeah. Just so I'm not
comparing strings. Yeah. So now that I've
introduced conditionals, it's important to do a
little bit more practice to get a mental model-- a mental model of how
to trace the code. And the visual structure of
the code actually helps a lot. And Python is
unique in the sense. There's no other
languages that actually force you to indent things. So other languages
don't really force you to have this
visual structure to match exactly
what's going on. But it's actually
really useful in Python. That's what I like about Python. It just helps you see things
that are going on immediately, like this set of code is
part of this code block. And so it helps you debug a
little bit more efficiently. But the more practice
you get, the more you'll get used to tracing the
code and knowing exactly if these variables
have this value exactly where your code is going to go. So I'm going to
skip this You Try It because it's just kind
of tracing the code and I'm going to have
you do this one-- or we can write it real quick. Or you can start and then
we can write it together. It's a variation of the
program you just wrote. Instead of telling me whether
the guess is true or-- is the same as
the secret number, I just want you to print whether
the guess is too low, too high, or the same as
the secret number. So we're going to need to
put a conditional in there, if some conditional, we're
going to print something. So I'll give you about
a minute and then we can write it together
and then we can be done. Oh, yeah? AUDIENCE: Can we have two if
statements into the program? ANA BELL: You can have two
if statements in the program, yeah. And there's actually
some exercises I have for you guys to
try at home here where there are two if
statements in the program, and just to see what happens. That starts two conditionals. So if some conditional,
that one can be true, and if some other conditional,
that one can also be true, and then both will be evaluated. It's not an else situation. Yeah. That's a good question. So I'm just going to copy
the input from before. Does anyone have a
start to my condition? I just copied what we
had before for the input. Yeah? AUDIENCE: So if I have
if x is [INAUDIBLE] and equal [INAUDIBLE]? ANA BELL: Yep. Yep. AUDIENCE: And then print-- ANA BELL: Print. AUDIENCE: Your
guess is "too high." ANA BELL: Yep. "too high." good. Yep. That's a great start. So we can even run it
and guess something that we know is too high. Perfect. Too high, yep. Next. Do you want to do
an else or an elif? Yeah? AUDIENCE: Actually, I would
get rid of the equal sign because if we put in a 5, now
it will still say too high. ANA BELL: That's a good point. So if we run it now-- let's run
it with a 5, it says too high. Exactly, yeah. So let's remove the equal sign. It's a good thing
we debugged that. So we can do an elif, the guess
is equivalent to the secret. And then we can print equal. Whoops. Does everyone understand why
we remove that equal sign from the greater than? Yeah? Because we would
have missed, yeah. We would have mistakenly
gone into that first path. But elif, we can
have a case where the guess is equivalent
to the secret, sure, and then we'll print equal. And then the last one
can either be an else because we know the only other
option is guess is less than, or we can do another
elif if we want to, but we can leave it
as an else, and then we can print "too low." And then we can run it and we
can guess all the variations. So something that's
too high, something that's the same, and-- I'm not sure what I did there. I should restart my kernel. So we did something
that's too high, something that is
equivalent, and then we can do something that's too low. OK-- yeah? AUDIENCE: What's the
difference between having else, else-if [INAUDIBLE]? ANA BELL: So there
is no difference. We can do an elif guess
is less than secret. That would-- the program
would work just the same. The else is just
quicker because we know there are no
other options here. AUDIENCE: Why wouldn't we just
put a row of if statements? ANA BELL: We could also--
in this particular case, we could also put a bunch
of if statements in a row, but then we'd have to
be careful that they are mutually exclusive. So like in the
previous example, if we have a bunch of conditions
that might all be true, all those ifs will execute. That's the thing-- because
the if starts a block. The elif is just
associated with that block. So either you do one or
the other or the other. But if you have a
whole bunch of ifs, then they might all be true
and they'll all be executed. Yeah. Yeah? AUDIENCE: Why don't
we use parentheses with an else statement? ANA BELL: Oh, we
could use parentheses in the if-else statements. You mean like this? Yeah, we can do that,
especially if we have a whole bunch of
expressions together, but if there's just one,
Python will automatically know to do the expression
first and then do the if. Yeah. These are all wonderful
questions, by the way. OK. So as we saw, there was
a little bug in our code. It's a good thing we ran it. I should have run it with a
bunch of different options, but it's important to
debug early and debug often just to make sure that
you don't introduce a bug that will kind of
carry on throughout the code. That's another big idea. And then a quick summary
of what we've learned. Input and outputs obviously
make our programs interactive. We added branching
as a way to introduce decision points in our program. And next time, we're going to
do a little bit more branching and then introduce looping-- so ways to repeat
commands in our programs. So I went a little
bit over time. I won't do that again.
