[MUSIC PLAYING]
DAVID MALAN: All right.
This is CS50, and this is the day before our test, of course.
But this is lecture 8, in which we're actually
going to finally transition from C, this lower-level language
that we've been spending quite some time to.
And the goal today isn't so much to focus on Python per se,
but honestly to do what we hope will be one of the most empowering aspects
of the class, which is to emphasize that this has not been a semester learning
C. This has been a semester learning programming,
a certain type of programming called procedural or imperative programming.
But more on that in another higher-level class perhaps.
But really, that this class is about ultimately teaching
yourself to learn new languages.
And indeed, what you'll find is that as we explore some of the features
and the syntax of Python, odds are today,
it might look as cryptic as C did just a few weeks ago.
But you'll find that once you start recognizing patterns,
as you have with C, it will be all the more accessible and all the more useful
when solving some problems.
So unrelatedly, just earlier this week, I happened to be in Mountain View
with some of the team.
And you might recall from last lecture at Harvard
we offered this glimpse of one of the earliest racks of servers
that Google itself had.
Well, turns out they changed buildings.
But we happened to stumble upon the actual display.
So pictured here is a photo from my own phone,
which was actually really cool to see.
So inside of this, you'll see all of the old hard drives they've used.
We actually looked at some of the labels.
And indeed, hard drives manufactured in 1999,
which is when Google started getting some of its momentum.
You can see the green circuit boards here,
on which would be CPUs and other things, potentially.
So if you'd like a stroll down memory lane,
feel free to read up on this on Wikipedia or even on the excerpts here.
And then strangely enough, at the conference some of us were at
did we discover this-- perhaps the biggest duck debugger made up
of smaller duck debuggers, one of whom was our own.
So that, too, was how we spent this past week.
All right.
So how are we going to spend this week and the weeks to come?
So you'll recall that when we transitioned from Scratch to C,
we drew a couple of comparisons between syntax and features.
And I thought it'd be useful to take that same approach here,
really to emphasize that most of the ideas we're going to explore today
are themselves not new.
It's just how you express them and how you
write the syntax in the language known as Python that's
indeed going to be different from Scratch, from C,
and now here we are with Python.
So back in the day, in week 0, when you wanted to say something in Scratch,
you would literally use this blue purple puzzle piece, say hello.
And we called that a function or a statement.
It was some kind of verb action.
And in C, of course, it looked a little something like this.
Henceforth, starting today in Python, it's going to look like this.
So before, after.
Before, after.
So it's pretty easy to visually diff these two things.
But what are just a couple of the differences
that jump out at you immediately?
C, Python.
So there's no more backslash n, it would seem, in this context.
So that's kind of a nice relief to not have to type anymore.
What else seems to be different?
No semicolon, thank god.
Right?
Perhaps the stupidest source of frustration
that you might have experienced by just omitting one of those.
And someone over here?
Yeah, so printf is now just print, which is pretty reasonable unto itself.
So these are terribly minor differences.
But it's sort of testament to the kinds of mental adjustments
you're going to have to start to make.
Fortunately, thus far we've seen that you can start leaving things off,
which is actually a guiding principle of Python in that one of its goals is it's
meant to be easier to write than some of its predecessors, among them C.
So in C we might have implemented this hello, world program that
actually ran when you clicked the green flag using code like that at the right.
And this was, if those of you who had no programming experience coming
in to CS50, what probably looked like the proverbial Greek to you
just a few weeks ago.
And we teased apart what those various lines meant.
But in Python, guess what?
If you want to write a program whose purpose in life is to say, hello, well,
just write def main.
Print hello, world.
So it's a little similarly structured.
And in fact, it does not lack for some of the more arcane syntax here.
But we'll see soon what this actually means.
But it's a little simpler than the one before.
And let's tease this apart.
So def here simply means define me, a function.
So whereas in C we've historically seen that you specify
the type that the function should return,
we're not going to do that in Python anymore.
Python still has data types, but we're not
going to explicitly mention what data types we're using.
Meanwhile, here is the name of the function.
And main would be a convention, but it's not
built into the language in the same way as it is in C, as we shall see.
Meanwhile, this silly incantation is just
a way of ensuring that the default function
to be executed in a Python program is indeed going to be called main.
But more on that when we actually start creating.
But this is perhaps the most subtle but most important
difference, at least early on.
And it's even hard to see at this scale.
But notice the colons both here and here that I've highlighted now in yellow,
and these dots, which are not to be typed,
but are just meant to draw your attention to the fact
that I hit the space bar four times in those locations.
So if you have ever sort of gotten some feedback from your TA or TF
that your style could be better, closer to 5 out of 5, because of lack
of indentation or pretty formatting, Python's
actually gonna help us out with this.
So Python code will not run if you have not invented things properly.
So gone are the curly braces that encapsulate related lines of code
within some block of functionality.
And instead, they're replaced generally with this general structure.
You have a colon, and then below that and indented
are all of the lines that are somehow related to that earlier line of code.
And the indentation must be consistent.
So even though your own eye might not quite
distinguish four spaces from three, the Python environment will.
And so this will actually help implicitly
enforce better style, perhaps, than might
have been easily done from the get-go.
So then, of course, in Scratch, we had a forever block,
which says, hello, world forever, much like in C, we
could implement it like this.
Now there's actually a pretty clean mapping in Python.
We already know we can get rid of the semicolon.
We already know we can get rid of the curly braces.
We're going to have to add in a colon.
But it turns out we can get rid of a little more, too.
So what more is absent from this translation of hello, world to Python?
This one's more subtle.
So we definitely got rid of the curly braces,
relying now just on indentation.
OK, so there's no parentheses around while.
And so this, too, is actually meant to be a feature of Python.
If you don't logically need parentheses to enforce order of operations,
like in arithmetic or the like, then don't use them
because they're just a distraction.
They're just more to type.
And the code now is just visually cleaner and easier to read.
There's a minor difference, too--
True and False are going to be capitalized in Python.
But that's a fairly incidental detail.
But notice this kind of captures already the spirit of Python.
It's not a huge leap to go from one to the other.
But we've just kind of started to get rid of some
of the clutter and the stuff that never really intellectually added much,
and if anything was annoying to have to remember early on.
So True here is our Boolean.
And now we have a finite number of iterations.
We might want to say hello, world exactly 50 times.
In C, this was a crazy mess if you wanted to do this.
You'd have to initialize a variable with which to count up to,
but not including 50, plus plussing along the way and so forth.
In Python, it's going to be a little cleaner.
And we'll come back to what this means exactly.
But if you kind of read it from left to right, it kind of says what you mean.
Right?
For i in the range of 50.
So i is probably going to be a variable.
And notice we're not mentioning its type.
It's going to be implied by whatever the context is, which in this case
has to do, apparently, with numbers, per the 50.
Range is actually going to be a data type unto itself.
It's a little funky in that sense.
It's called a class.
But this essentially is a special feature of Python that, unlike in C,
where if you want to iterate over an array of values or 50 such values,
you would literally have an array of 50 values.
Range is kind of cool in that it kind of stands there.
And every time you iterate through a loop, it hands you the next number,
but just one at a time, thereby using maybe as little as one
50th the amount of memory because it only has to keep one number around
at a time.
And there's a bit more overhead than that.
It's not a perfect savings, quite so.
But this just says for i in range 50, and that's
going to implicitly count from 0 up through 49.
And meanwhile, what's below it is what's going to get printed this time.
So meanwhile, here was one of our bigger Scratch blocks early on.
And i translates pretty literally to code in C.
And you can perhaps guess, if you've never
seen Python before today, what the Python code might now look like.
If this here on the right is the C code, what
are some of the features syntactically that we're about to throw away?
Yeah.
AUDIENCE: You can throw away the curly braces and the parentheses.
DAVID MALAN: Curly braces and parentheses are going to go away.
What else might go away?
The semicolons are going to go away.
The backslash n inside of the print statements.
Great.
One more thing, I think.
The if.
So we don't strictly need the parentheses
because it's not like I'm combining things logically
like this or that or this and that.
So it should suffice to get rid of those two.
And there's a couple of other tweaks we're going to have to make here.
But indeed, the code's going to be a lot tighter, so to speak.
Now you're just going to say what you mean here.
And there is one weird thing.
And it's not a typo.
What apparently are we going to have to start knowing now?
Elif whatever.
So elif is not a typo.
It's indeed how you express the notion of else-if.
But otherwise, everything is exactly the same.
And notice the colons.
Frankly, ironically, whereas previously it
might have been annoying to occasionally forget a semicolon,
now the colons my take on that role.
But at least everything below them is meant to be indented.
So here's a fundamental difference beyond the sort of silly syntactic
differences of this and, say, other languages--
the flow of work that we've been using thus far has been essentially this
in C. You write source code in a file generally ending in .c.
You run a compiler, which, as a quick check, is called clang.
So it's not technically make.
Make is just this helpful build utility that
automates the process of calling clang.
So clang is, strictly speaking, the compiler.
And clang outputs zeros and ones, otherwise known as machine code.
And your computer-- Mac, PC, whatever-- has a CPU, Central Processing
Unit inside, made by Intel or some other company.
And that's CPU is hardwired to understand
certain patterns of bits, zeros and ones, otherwise known as machine code.
So that's been our world in C.
With Python-- so the code that you might have compiled in C,
for instance, might have been this, which
we said we run clang on like this.
And if you don't specify a default file name as output,
you'll instead just get in your file all of the zeros and ones,
which can then be executed by way of ./a.out,
the default name for the assembler's output here.
So in Python, though, the world gets here, too, a little simpler, as well.
So we just now have source code and an interpreter.
So there's no machine code, it would seem.
There's no compiler, it would seem.
And frankly, there's one fewer arrow, which
suggests to me that the process of running Python code itself
is actually going to be a little easier.
Running C code has typically been two steps.
You rerun clang, or via make you run clang.
Then you run the program.
And it's fine.
It's not all that hard.
But it's two steps.
Why not reduce to two steps what you could instead do in one?
And we'll see exactly what this means.
Now, technically, that's a bit of an oversimplification.
Technically, underneath the hood, if you wanted
to run a program like this that simply prints out hello, world,
you would simply run python hello.py.
And the result of that would be to see hello, world on the screen,
as we'll soon see.
But technically, underneath the hood, there is some other stuff going on.
So there actually kind of is a compiler.
But there's not something called machine code, per se.
It's called bytecode.
There's even something called a Python virtual machine.
But all of this is abstracted away for us,
certainly for the sake of today's conversation,
but also in the real world, more generally.
Humans have gotten better over the decades
at writing software and writing tools via which we can write software.
And so a lot of the more manual processes
and a lot of the lower-level details that we've
been focusing on, if not struggling on, in C, start to go away.
Because much like in week 0, where we started layering on idea after idea--
zeros and ones, ASCII, colors, and whatnot--
similarly with our actual tools are we're going to start to do the same.
So whereas in actuality what's going on underneath the hood is
this process here, we can start to think about it,
really, as something quite simpler.
Now, if you're curious, and if you take some higher-level class
like CS61 or another, you'll actually talk
about things like bytecode and assembly code and the like.
And we saw a glimpse of the latter a bit ago.
This happens to be an intermediate language
that Python source code is converted into before it's run by the computer.
But again, we're going to turn a blind eye to those lower-level details.
So here are some of the tools now in our toolkit.
In Python, there are data types, though as of now we've
not seen any examples whereby I specify what types of values
are going to be in my variables or what types of values
a function's going to return.
But they are there.
Everything is sort of loosely typed in that
whatever you want a variable to be, it will just take on that data type,
whether it's an int or string or the like.
It's not going to be the full word string.
In Python, it's literally called str.
But there are some familiar types here-- bool and float and int and others.
And, in fact, among the others, as we'll soon see, are features like range.
But before that, note too that we'll provide for at least our first foray
into Python a few familiar functions.
So Python has different mechanisms than C for getting input from the user.
We've abstracted some of those details away in a new CS50 library for Python
that you'll really just use one or few times before
we transition away from even that, but will give you functions like get_char,
get_float, get_int, get_string that handle all the requisite error checking
so that at least for your first few programs,
you can just start to get some real work done
without diving into underneath the hood there.
And then lastly, here are some other tools in our toolkit.
And we'll just scratch the surface of some of these today.
But what's nice about Python and what's nice about higher-level languages more
generally-- like more modern languages that learned lessons from older
languages like C--
is that you get so much more for free, so much more out of the box.
There's so much more of a kitchen sink.
There's so many metaphors we can use here, all of which speak to the fact
that Python has more features than C, much like Java,
if you took AP CS or something else, had than C.
So does Python have a whole toolkit for representing complex numbers,
for representing dictionaries, otherwise implemented as hash tables,
as you now know; lists, which is kind of synonymous with an array.
But a list is an array that can sort of automatically grow and shrink.
We don't have to jump through hoops as we did in C. Range we've seen briefly,
which just hands you back one number after another in some range, ideally
for iteration.
Set is the notion from mathematics, where
if you want to put bunches of things into a data structure
and you want to make sure you have only one of each such thing
without duplicates, you can use a set.
And a tuple is also a mathematical notion,
typically where you can combine related things without complicating things
with actual structs.
Like, x, y is a common paradigm in lots of programs-- graphics,
or videos, or certainly math and graphing itself.
You don't really need a whole full-fledged data structure.
You might just want to say, x, y.
And so Python gives us that kind of expressiveness.
So let's actually now dive in with that quick mapping
from one world to the other and focus on what you can actually do with Python.
So here I am in the familiar CS50 IDE.
Much like we have pre-installed for you clang
and make and other tools, we've also installed for you a program.
That program is called Python, which is a little confusing at first glance
because Python is apparently the name of the language.
But it's also the name of the program.
And here's where Python is different.
Whereas C is again compiled, and you use something
like clang to convert it to machine code,
Python is both the name of the language and the name of the program you
use to interpret the language.
So pre-installed in CS50 IDE, and frankly, these days,
probably on your own Macs or PCs, even if you don't know it,
is a program called Python that if fed Python source code as input
will do what that code says.
So let's go ahead and try something just like that.
Let me go ahead and save a file preemptively as hello.py.
So .py will be the convention now instead of .c.
And I'm going to go ahead and actually keep this pretty simple.
I'm just going to print the first thing--
muscle memory.
So it's not printf anymore.
It's just hello, world.
Save, done.
That's going to be my first program in Python.
Why?
It's one line of code.
It's consistent with the features I've claimed Python has.
So how do I run it?
Well, in C, we would have done, like, make hello.
But make knows nothing about this because make is typically used with C,
at least in this context here.
So maybe it's, like, ./hello.py.
No.
It seems I don't have permission there.
But there's a step that I teased us with earlier on just the slide alone.
How do I go about running a program, did I say?
AUDIENCE: Python hello.py.
DAVID MALAN: Yeah.
I have to be a little more explicit.
So python, which is the name of the interpreter that understands Python.
And now I need to feed it some input.
And we know from our time in C that programs
can take command-line arguments.
And indeed, this program itself does, Python.
You just give it the name of a program to run.
And there it is, our very first program.
So that's all fine and good.
But what if I wanted to do something a little more interesting,
like getting a string from the user?
Well, turns out in Python, in CS50 IDE especially,
I can do something like this. s gets get_string.
And I can ask someone, for instance, for their name, like this.
Now, CS50 IDE is already yelling at me--
undefined variable get_string.
and let's actually see if maybe it's just buggy.
No.
So this is a little more arcane than usual.
But traceback, most recent call last.
File "hello.py," line 2, in module-- whatever that is.
So I see a line of code from line 2.
NameError-- name get_string is not defined.
This is not the same language we've seen before,
but what does this feel reminiscent of?
Yeah, like in the past, when you've forgotten cs50.h,
you've gotten something about an undeclared identifier, something
like that.
It just didn't understand something related to the CS50 library.
So in C, we would have done include cs50.h.
That's no longer germane because now we're in Python.
But it's somewhat similar in spirit.
Now I'm going to say instead from cs50 import get_string, and now save that.
And hopefully momentarily, the errors will go away as the IDE realizes,
oh, you've now imported the CS50 library,
specifically a method or function, rather, inside of it called get_string.
So there, too, it's different syntax, but it kind of
says what it means-- from cs50, which is apparently the name of the library,
import a function called get_string.
Now if I go ahead and rerun python hello.py,
I can go ahead and type in, say, Maria's name
and ignore her altogether because I need to make a fix here.
What's the obvious bug--
obvious now, to me-- in the program?
AUDIENCE: You need to include the variable for s.
DAVID MALAN: Yeah.
So I need to include s, which I got on line 3,
but didn't thereafter use in any way.
So this is going to be wrong, of course, because that's going to say,
literally, hello s.
This is kind of how we used to do it.
And then we would put in s.
But this is not printf.
This is print.
So the world is a little different.
And it turns out we can do this in a couple of different ways.
Perhaps the easiest, if least obvious, would
be something like this, where I could simply say hello,
open curly brace, close curly brace.
And then inside of there, simply specify the name of the variable
that I want to plug in.
And that's not quite all the way there.
Let me go ahead and run this once more.
Now if I type in Maria's name, oh.
Still not quite right.
I need to actually tell Python that this is a special type of string.
It's a formatted string, similar in spirit to what printf expected.
And the way you do this, even though it's a little different from C,
is you just say f.
This is an f string.
So literally before the quotes, you write the letter f.
And then if I now run this program here, i'm
going to actually see Maria's name as hello, Maria.
And I'll take care of that red X later.
So that's a format string.
And there's one other way.
And this is not very obvious, I would say.
You might also see in online documentation something like this.
And let's just tease this apart for just a second.
It turns out in Python that what I've highlighted in green
here is known as a string, otherwise known as a str.
str is the name of this data type.
Well, unlike in C, where string was kind of a white lie, where it was just
a pointer at the end of the day, a string
is actually a first-class object in Python, which means
it's not just a sequence of characters.
It has built-in functionality, built-in features.
So much like a struct in C had multiple things inside of it,
so does a string in Python have multiple things inside of it,
not just the sequence of characters, but functions that can actually do things.
And it turns out you access those functions by way of the same dot
operator as in C. And then you would only
know from the documentation or examples in class what functions are inside
of the string object.
But one of them is format.
And that's just a function that takes an argument-- what
do you want to plug into the string to the left of the dot?
And so simply by specifying, hey, Python,
here's a string with a placeholder.
Inside of this string is a built-in function-- otherwise known
as a method, when a function is inside some object or structure--
pass in the value s.
So if I now go ahead and rerun this after saving my changes,
I should now see that Maria's name is still plugged in.
So that's it.
But a simple idea that now even strings have
things inside of them besides the characters alone,
and you can access that via the dots.
So let's go ahead now and ramp things up to a more familiar example from a while
back.
Let me go ahead and open up two side-by-side windows
and see if we can't translate one to the other.
I'm going to go ahead and open up, for instance, int.c from some time ago.
So you might recall from int.c, we had this program, whose purpose in life
was to get an integer from the user and actually now plug it into printf,
and then print it out.
So what's going to be different now in Python?
Well in Python, if I go ahead and implement this as, say, int.py,
I'm going to go ahead and do the following.
Let me scroll down to kind of line things up roughly.
I can go ahead and say def main, as I saw in the slides before.
And then over here, I can say i gets get_int, quote, unquote, integer.
And then down here, I'm going to say not printf but print, quote, unquote,
"hello," and then the placeholder.
What's the simplest way to do this now, per our past example?
Curly brace i.
And then I just need to be super clear this is a special f string or format
string, into which you can plug in values.
And now I'm going to go ahead and save that.
And I've got most of the pieces together,
ignoring, for now, the red X. So what more remains to be done?
I've made one same mistake as before.
Yeah, so the get_int. so up here, really the equivalent of line 3
would be from cs50 import get_int this time.
Saving that.
And now if in my terminal window I go ahead and run python of int.py--
hmm.
That seems strange.
It's not an error, in terms of, like, erroneous output.
Just nothing happened.
So why might this be?
How might you go about troubleshooting this, even with very little Python
under your belt?
Was that a hand, or no?
No?
OK.
Yeah?
AUDIENCE: Is there a line break?
DAVID MALAN: Is there a line break?
That's OK.
I was just doing that to kind of make everything line up.
But it's no big deal.
Everything's indented properly, which is the important aesthetic.
Yeah.
AUDIENCE: We didn't call the function.
DAVID MALAN: We didn't call the function.
And this is where Python's a little different from C. In C, recall,
main just gets called automatically for you.
Humans years ago decided that shall be the default name of a function.
In Python, line 6 here, calling something main is just a convention.
I could have called it foo or bar or any other word.
It has no special meaning.
And so in Python, if you want to actually call main,
you need to do something, frankly, that's,
I think, one of the stupider distractions early on.
But you have to literally say this--
if the name of this file happens to equal something that's
specially called main, then call main.
So long story short, when you run the Python interpreter on a file,
as we've been doing with python, space, int.py or hello.py,
there is a special global variable that your program has access to called
__name__.
And if that default name happens to be __main__,
then you know that you have the ability to call any function you want
by default.
So for now, much like we did in week one,
where we glossed over certain details that just weren't all that interesting,
lines 11 and 12, for now, let's consider not all that interesting.
But it's how we're going to kick-start these programs.
Because now if I run python, space, int.py, type in a great number--
hello, 42.
That's the meaning of life, the universe, and everything.
So let's now actually do something more powerful
than just getting a single int from the user.
Let me go ahead and close off this one and close off this one
and open up, say, ints.c after splitting my window again into two windows here.
And let's open ints.c.
So this one was a little different in that we did some arithmetic.
And so here is going to be another difference in Python.
Here's what we did in C. And what was curious or worth
noting about math in C?
Which of these did not quite behave as you might expect in the real world?
Division?
Yeah, why?
What did division do?
Yeah, it chopped off or rounded down.
It floored the value by throwing away everything after the decimal point.
So this line here, 18, where it's such-and-such divided by such-and-such
is such-and-such.
And we literally just said x divided by y.
If you divided, for instance, 1 divided by 2 in grade school, hopefully,
you would get the value 1/2 or 0.5.
But in C, what did we get instead?
AUDIENCE: Zero.
DAVID MALAN: Zero.
So it gets truncated to an int, the closest int
without a decimal point being 0 because 0.5 is really 0.5.
And thus we had that effect.
So in Python, things are going to be similar in spirit.
But this is kind of a feature that was fixed or a bug that was fixed.
In Python-- let me go ahead here and open up an example
I wrote in advance called ints.py, which is actually
now going to look like this.
So the Python equivalent now, which I've roughly line up,
looks a little different.
And there's a few distractions because we have all these f strings.
Now in the way.
But notice I'm just plugging in x's and y's.
But what's a new feature, apparently, in Python, arithmetically?
So floor division.
So this was the more proper term for what C has been doing all this time.
In C, when you use use the slash and you divide one number by another,
it divides, and then floors it to the nearest int.
In Python, if you want that same old-school feature,
you're going to now use slash slash, not to be confused with the C comment.
And if you want division to work the way you always knew it did in grade school,
you continue using just the slash.
So a minor point, but one of the differences to keep in mind.
So if we actually run this here in Python, if I go into source 8 today
and our week's directory for week 1, and I run Python ints.py,
here now we're going to see 1 and 2.
And there's all of the values that we would expect to see.
All right.
So without dwelling too much on this, let's fast forward to something
more powerful like conditions.
So in Python, if we want to do something only conditionally,
laying out my browser like this, let me go ahead and open up, let's say,
conditions.py.
Sorry, conditions.c, which once upon a time looked like this.
So in this example here, notice that we have
a program that gets two ints from the user,
and then just compares x and y and x and y and prints out
whether they're greater than, less than, or equal to, ultimately.
So let's actually do this one from scratch over here on the right.
So let me go ahead and save this as conditions.py.
And then at the top, what's the very first thing
I'm going to apparently now need?
Yeah, so the CS50 library.
So from cs50 import-- it looks like get_int is the one we want this time.
Now, how do I go about getting an int?
Or what's the translation of line 9 on the left
to the right-hand side of the screen?
x equals get_into of the same prompt.
OK, what comes next, if I line it up roughly here?
y gets get_int of quote, unquote, y.
And what's down here?
The condition.
So if x less than y?
No parentheses are necessary.
It's not wrong to put them, but it's unnecessary.
And now enters a word into our terminology--
it's not Pythonic, so to speak.
If you don't need them, don't put them.
So if x is indeed less than y, what do we want to do?
We want to print x is less than y, yes?
No.
OK.
All right, good.
So else if x--
OK, good.
Right.
So, kind of goofily, elif, then go ahead and print out x is greater than y.
And as an aside, I actually did that accidentally.
But it turns out in Python, too, you can use double quotes or single quotes.
Either is fine, whereas in C, single quotes had a very specific meaning,
which meant what?
AUDIENCE: Char.
DAVID MALAN: Char.
So single characters.
And double quotes meant strings, sequence
of characters, which meant zero or more characters, followed by backslash 0.
In Python, all of that is gone.
Single quotes and double quotes are equivalent.
I'll almost always use double quotes, just for consistency, as should you,
for consistency, within your own files.
But sometimes it's useful to drop into one or the other if you nest,
for instance, quote marks, as you might have once in a while in C
OK.
So finally, else print out x is equal to y.
So it's cleaner.
And frankly, I don't need all this whitespace.
So let's go ahead and just make this a little tighter still.
You can see that in 11 lines, we've now done what took 27 or so last time.
But I have omitted something, to be fair.
What did I omit?
Yeah, I didn't do that whole calling of function thing.
There's no mention of main.
And it actually turns out that's not strictly necessary in Python.
If you're going to be interpreting a file that contains Python code,
and it's a simple enough program that you don't really need to factor code
out and organize it into separate functions, then don't.
If this is what would now be called a command-line script,
a program that just has lines of code that you can execute, literally,
at the prompt.
So if I go into this directory and run python of conditions.py, Enter.
x will be 1. y will be 2.
x is indeed less than y.
And that's it.
I don't need to bother doing all of this, as I proposed earlier.
def main, and then I could go in here.
And if you've never known this, and now it's useful,
especially, for Python, you can highlight lines and just
tab them all at once.
I could do this, but then I would need this thing, which I'd probably
have to go look up how to remember it, if you're doing it for the first time.
There's just no value in this case to doing that.
But at least it can be there as needed.
So let me go ahead and undo that.
And we're back to a porting of one to the other.
All right.
So that might then be conditions.
And let's see if we can't--
noswitch there.
Let's take a look at this one.
Let me open up, rather than comparing all of them side-by-side,
let me just open up this one now called noswitch.py,
which is reminiscent of a program we ran some time ago called noswitch.c.
And you can perhaps infer what this does from the comments alone.
What does this program do in English?
Because logical operators is not all that explicit at top.
What's that?
Yeah.
So if you've ever interacted with a program that asked you for a prompt,
yes or no, here's some code with which you might implement it.
And we could do this in C. We're just comparing characters here.
But there's a few differences if you kind of now
think back to how you might implement this in C,
even if you don't recall this specific program.
I'm importing my library right up here.
I'm then calling get_char this time, which
is also in CS50's library for Python.
And then notice there's just a couple of things
different down here syntactically.
Besides the colons and the indentation and such, what else is noteworthy?
Yeah.
Thank god, you can just say more of what you mean now.
If you want to do something or something, you literally say or.
And if we were instead--
albeit nonsensically here-- trying to do the conjunction of two things, this
and that, you could literally say and.
So instead of the two vertical bars or the two ampersands,
here's another slight difference in Python.
Let's now take a look at another example reminiscent of ones past,
this one called return.py.
So here's an example where it's actually more
compelling to have a main function because now I'm
going to start organizing my code into different functions still.
So up here, we are importing the get_int function from CS50 library.
Here I have my main function just saying x gets get_int.
And then print out the square of x.
So how do you go about defining your own custom function
in Python that's not just main?
Well, here on line 11 is how I would define a function called square--
that takes, apparently, an argument called n,
though I could call this anything I want-- colon, return, n, star star, 2.
So a few new features here.
But again, it's no big deal once you just kind of look these features up
in a manual or in a class.
What is star star probably doing?
AUDIENCE: Square root.
DAVID MALAN: Not square root.
The power of, yeah.
So n star star 2 is just n raised to the power of 2.
That was not a feature we had in C. So now we get this in Python.
And what's this line 12 in green with the weird use of double quotes?
Yeah, it's a comment.
And it's a different type of comment than we've
seen before because in my previous example, I did have a few comments.
Recall that just a moment ago, in conditions.py,
we had a whole bunch of comments.
Prompt the user for x.
Prompt the user for y.
Compare x and y.
So whereas in C we were using slash slash,
Python, unfortunately, uses that for floor division, so to speak.
So we instead just use the hashtag or the pound sign
to specify a line that should be thought of as a comment.
But here is something a little different.
And we won't dwell too much on this for now.
But Python has different types of comments, one of which is this.
This is technically called a docstring or document string.
And what's nice about Python, as well as languages like Java and others still,
is that you can put comments in your code
that special programs can read, and then generate documentation for you.
So if you ever took AP CS and you ever saw a Javadoc,
this was a way of commenting your methods
and your code in Java using funky @ signs and other syntax
so that if you ran a special command, it could generate a user's manual for all
of your functions and tell you or colleagues or friends or teachers
exactly what all your functions are, what their arguments are,
what their return values are, and all of that.
Similarly in Python can you use these funky quote quote quote
docstrings to document your function.
So whereas in C our style has been to put quotes above the functions,
in Python it's going to be to put them as the first line inside
and indented within the function.
All right.
So now let's actually try to port a program from code again,
thinking back on week one in C when we had this program here.
So there's quite a bit going--
oops, spoiler.
Don't look at that.
Hopefully, that didn't sink in just yet.
So in week one, we had this program in C, get_positive_int.
And its purpose in life was to write a program that
gets a positive integer from the user, in and of itself
not all that interesting.
But it was an opportunity to introduce a few things.
One, we introduced this line 6 several weeks ago,
which is known as a prototype.
And what was the purpose of having that function prototype up there?
Yeah, you declare the function, but why?
Because it's already implemented down here on line 15.
AUDIENCE: The way the program runs, it needs to be in order or something
like that.
DAVID MALAN: Yeah.
Because of the way the program's run, and frankly
because of how sort of naive or dumb that clang is by design,
it does not know that a function exists until it actually sees it.
So the problem is that if in C, you have main, inside of which
is a call to function like get_positive_int,
but it's not implemented until a few lines later,
clang is going to be dumb and just not know that it even exists.
And it's not going to compile your code.
So this prototype, as we called it, is kind of a teaser, a hint, that
doesn't implement the whole function.
It just shows the compiler its return type and its types
and order of parameters so that that's enough information
to then just trust that if I just blindly compile main,
eventually I'm going to see the actual implementation of the function.
So I can compile its bits, as well.
So in here, in C, we called get_positive_int,
and then we passed in a prompt.
We stored it in a variable calle i, and then printed it out.
And then to implement this, we used kind of a familiar construct
that you've used in other programs.
Pretty much anytime you want to prompt the user for input,
and you want to keep pestering him or her
until they cooperate with whatever your conditions are,
you would use the so-called do-while loop.
And because the do-while loop, recall, is distinct from the while loop how?
AUDIENCE: It runs at least once.
DAVID MALAN: It runs at least once, which
just kind of makes intuitive sense if you
want to prompt the user for something.
And then if he or she doesn't cooperate, only then
do you want to prompt them again.
By contrast with a while loop, it's going to happen again and again
and again no matter what, from the get-go.
So let's see if we can't now convert this or port
this, as people would say, to Python.
So here I'm going to go ahead and save a new file called positive.py.
And I'm going to go ahead and do everything here in main, as before.
So I'm going to ahead and do, let's say, from cs50 import get_int,
because I do need that.
And then I'm going to go ahead and have my main method here.
And then inside of main, just like on the left-hand side,
I'm going to do i gets get_positive_int--
positive integer, please.
It's going to wrap a little bit now.
That's fine.
And then I'm going to go ahead and print this, which, recall,
is just print an f string where the placeholder is i,
although, frankly, this is kind of stupid,
to just create a string that has nothing other than the value we want to print.
Nicely enough in Python, just print what you want.
And so that simplifies that argument.
So now it remains to implement get_positive_int,
which is going to take some kind of prompt as its input.
And notice I'm not specifying the data type of prompt, which is string.
I'm not specifying the return type of this function.
But both actually do exist underneath the hood.
So in the past, to get a variable, I would do something
like this, semicolon.
But I know I don't need the semicolon.
I know I don't need the data type.
And this just looks stupid to just put a variable there to need it.
You don't need to do this in Python.
If you want to use a variable, just start using it.
And unfortunately, whereas almost every other feature we've seen in Python
thus far kind of maps directly back to a feature in C,
Python does not have a do-while.
So it has the for-in, and it has while.
And maybe it has other things we haven't told you about.
But it doesn't have do-while.
So knowing that, and knowing only what we've presented thus far,
how do we still go about getting an int from the user
and ensuring it's positive and reprompting him or her if and only
if it's not?
Put another way, how would you do this in C if we took away from you
the do-while construct?
Exclamation points?
OK.
So we could invert something, maybe, using that logically.
AUDIENCE: You can just do a while loop.
DAVID MALAN: We could just use a while loop.
How?
AUDIENCE: So while prompt is less than 1.
DAVID MALAN: So while prompt is--
OK, so the prompt is the string we're going to display to the user.
So it's not prompt, I think.
So maybe i or n, to be consistent with the other side.
So you know what?
Why don't I-- what about this?
What if I just do-- you know what?
I know I need a loop.
This is by far the easiest way to just get a loop, right?
It's infinite, which is not good.
But I can break out of loops, recall.
So what if I do something like this?
What if I do n gets get_int, passing in the same prompt?
And then what do I want to do next?
I'm inside of an infinite loop.
So this is going to keep happening, keep happening, keep happening until--
is positive?
So python's not quite that user-friendly.
We can't just say that.
But we can say what?
AUDIENCE: Greater than 1.
DAVID MALAN: Greater than--
close.
AUDIENCE: Equal to.
DAVID MALAN: OK, that's fine.
Greater than or equal to one.
Then what do we want to do?
Break.
So it's not quite as cool as, like, a do-while loop,
which kind of gives us all these features, though frankly, this
was never that pretty, right?
Especially the fact that you had to deal with the issue of scope
by putting the variable outside.
So in Python, the right way to do this would be something like this.
Just induce an infinite loop, but make sure you break out of it logically
when it's appropriate to do so.
And so now if I go ahead and add in that last thing that I keep needing--
so if name equals main, and it's always find to copy-paste something like that,
call main.
Let me go ahead now and in my terminal window run python of positive.py.
And let me go ahead and give it negative 5.
How about negative 1?
How about 0?
Whoops.
How about that?
How about 0?
1?
Hmm.
I screwed up.
None is interesting.
It's kind of our new null, so to speak.
But whereas in C, null can, potentially, if used in the wrong way,
crash your program, Python might just print it, apparently.
Where did I screw up?
Yeah, so I didn't return an actual value.
And whereas clang might have noticed something like this, Python,
the interpreter's not going to be as vigilant when it comes to figuring out
if your code is missing something.
Because after all, we never said we were going to return anything.
And so we don't strictly need to.
So what could I instead do here instead of break?
I could just return n here.
Or I could equivalently do this, and then just make sure I return n here.
And another difference in Python, too, is that the issue of scope
isn't quite as difficult as it was in C. As soon as I've declared n to exist up
here, it now exists down below.
So even though it was declared inside of this indentation,
it is not scoped to that while loop alone.
So either way could we actually make this work.
OK, so now let's try to run this again.
Positive integer.
Negative 1.
0.
1.
And now we're actually seeing the number 1.
All right.
Let me pause here for just a moment and see if there's any questions.
No?
Yes.
AUDIENCE: Do you to call things from the CS50 library individually,
or can you just import the entire library?
DAVID MALAN: Ah, good question.
Do you have to call things inside of the CS50 library individually,
or can you import the whole thing?
You can technically import the whole thing as follows.
If you want access to everything in the CS50 library,
you can literally say star.
And a star in programming-- well, in many computer contexts,
star generally is a wildcard character.
And it means anything that matches this string here.
This is generally considered bad practice, though.
Because if CS50 staff happens to give you functionality or variables that you
don't want, you have now just imported into your namespace,
so to speak, all of those functions.
So for instance, if the CS50 library had public inside of it
a variable called x and y and z in addition
to functions like get_string and get_int and get_char,
your program is now seeing variables x and y and z.
And if you have your own variables called x and y and z,
you're going to shadow those variables inside ours.
And it just gets messy quickly.
So generally, you want to be a little more nitpicky
and just import what you want.
Or, another convention in Python is to not specify it like this,
but instead to do import CS50.
This does not have the same effect of importing
all of those keywords like get_int and get_string
into your program's namespace, like the list of symbols
you can actually type in.
But what you then have to do is this--
you have to now prefix any usages of the functions in that library
with the now familiar or more familiar dot operator.
So this is just a stylistic decision now.
I have consciously chosen the other approach
so that initially, you can just call get_int, get_string, just like we
did in C. But technically and probably more conventionally would
people do this to make super clear this isn't my get_int method.
It's CS50's get_int function.
OK.
Other questions?
Yeah.
AUDIENCE: Is it good coding practice to do the if __name__ or just--
because you can run hello, world without defining main.
Do you really need to do--
DAVID MALAN: Oh, it's a good question.
Short answer, no.
So I'm showing you this way because you'll
see this in various examples online and in programs
that you might look at that are open source.
Strictly speaking, this is not necessary.
If you end up making your own library, this tends to be a useful feature.
But otherwise, I could equivalently do this, which is perfectly fine as well.
I can still define get_positive int.
I can get rid of main altogether.
And I can just now do this.
So this program is equivalent and just as fine for now.
OK.
So with that said, let's do a couple of more examples
here to kind of paint a picture of some of the things
that are similar and different.
And let's go ahead and open up, for instance, overflow.c from some weeks
ago, splitting our windows again.
And then on the right-hand side, let me open up something called overflow.py,
which I put together in advance.
So here we have on the left an example of integer overflow, whereby
if I start counting at 1, and then don't even have a condition,
and I just keep multiplying i by 2, by 2, by 2,
doubling it, doubling it, doubling it, doubling it,
we know from C that bad things happen if you just kind of keep
incrementing something without any boundary in sight.
So this program is just going to print out each of those values,
and it's going to sleep one second in between.
Same program in Python looks pretty similar.
But notice I'm initializing i to 1, doing the following forever--
printing out i, multiplying i by 2, and then sleeping for one second.
But sleep is also not built into Python in the way that print is.
Notice what I had to include up here.
And I wasn't sure what that was.
And so honestly, just a few days ago, I googled,
like, "sleep one second Python," saw that there's this time library, inside
of which is a sleep function.
And that's how I knew which library to actually include.
And so just as there are man pages for C,
there's a whole documentation website for Python
that has all of this information, as well.
So let me go ahead and do this.
And let me actually try to create two windows here.
What's the best way for me to do this?
Split one to two.
OK.
So let's do this, just so I can run this in the same place.
So if I go into my source--
[POPPING NOISE]
Jeez.
My source 8 directory, and I go into weeks and one, and I make overflow--
nope, sorry.
Week one.
OK.
So if I go into source one, and I do make overflow,
which is kind of cute semantically, I'm now
going to be able to run a program called overflow.
Meanwhile, over here, let me go ahead and split this window, too.
Dammit, not there.
Let's put this over here.
Oh, no!
OK.
One second.
Sorry.
Overflow.py.
OK.
So now we're-- oh, now I lost the other window.
Oh, that's cool.
OK.
So let's do this.
OK.
Now I know how to use the IDE.
All right.
So on the left-hand side, I'm about to run overflow.
And then lastly, without generating that beep again, I'm going to go in here.
And I'm about to run python of overflow.py.
All right.
And so the left will run the C version.
The right will run the Python version.
And we'll start to see--
no pun intended-- what happens with these programs.
Oh, damn it.
I got to scroll.
OK, so I'll just keep scrolling for us.
This is fun.
OK.
Next time, Google how to sleep for half a second instead.
OK.
So there we go.
Something bad has happened here.
And now C is just completely choking.
Things are in a funky state.
So what happened on the left, before the answer scrolls away?
Integer overflow, right?
We had so many bits becoming ones, that eventually, it
was mistaken for a negative number temporarily.
And then the whole thing just kind of got confused
and became permanently zeros.
Whereas on the right-hand side, like, yeah, Python.
Look at you go.
Still counting higher and higher and higher.
And even though we haven't talked about the underlying representation
of these types in Python, what can we infer
from the apparent better correctness of the version on the right in Python?
It's not an eight-bit representation.
And even C, to be fair, uses 32 bits for its ints.
And that's what we got as high as 2 billion or 4 billion in total.
But same idea.
How many bits must Python be using?
AUDIENCE: 64?
DAVID MALAN: Yeah, maybe 64.
I don't know exactly.
But I know it's not 32 because it's keep counting up and up and up.
And so this is another feature of Python.
Whereas int in C has typically been for us 32 bits--
although that is technically machine-specific--
Python integers are now going to be 64, which
just means we can do much bigger math, which
is great for various data-science applications and stats and whatnot,
where you actually might have some large data sets to deal with.
Unfortunately, we still have some issues of imprecision.
Let me go ahead and close a whole bunch of these windows
and go ahead and open up, for instance, just this one here.
OK.
No, I'm going to skip this and do something
slightly more fun, which is this.
So in Python here, let's do a quick warm-up.
This is going to print for me what?
AUDIENCE: Four question marks.
DAVID MALAN: 4 question marks, right?
And this is reminiscent-- this is like a really cheap version of "Super Mario
Bros."
And if you think back to week one, where we explored this,
there was a screenshot I had of "Super Mario Bros," one of the worlds
where we just had four question marks which Mario could hit his head against
to actually generate a coin.
So we stepped up from there in C to do this instead.
And this is going to give us another feature.
But let's see if we can't start to infer from context what these programs do.
Here's another one, mario1.
What's this do?
It's using a loop, for sure.
And it's using how many iterations, apparently?
Four.
So from 0 to 1 to 2 to 3, total.
Each time, it's going to print out, apparently, a question mark.
But now, just infer from this--
I haven't answered this question already--
what else is going on line 4 and why?
AUDIENCE: It's not going to a new line.
DAVID MALAN: Not going to a new line, right?
So there's always this trade-off in programming and CS more generally.
Like, yay, we took away the backslash n, which was annoying to type.
But now if it's always there, how do you turn it off?
So this is one way to do that, and it also
reveals another fundamental feature of Python.
Notice that print apparently takes, in this case, more than one argument.
The first is a string-- literally quote, unquote, and a question mark.
The second is a little funkier.
It's like a word, end.
It's then an equal sign, and then it's a quote mark.
So what is this here?
So it turns out Python supports what are called named parameters.
So in C, any parameters you pass to a function
are defined, ultimately, by way of their order.
Because even if a function takes arguments that have names,
like x and y or a and b or whatever, when you call the function,
you do not mention those names.
You know they exist, and that's how you think about them in the documentation
or in the original code.
But you don't name the arguments as you pass them in and call a function.
You instead pass them in in the appropriate order per the man page
or per the documentation.
In Python, you can actually be a little more flexible.
If a function takes multiple arguments, all of which have names,
you can actually mention the names explicitly,
thereby freeing you from the minor inconvenience
of having to remember and always get right the actual order of arguments.
So in this case, print apparently takes at least two arguments
in this case, one of which is called end.
And if you want to use that one, which is clearly optional because I haven't
used it yet, you can literally mention it by name, set an equal sign,
and then specify the value that you want to pass in.
So if I actually now go into this and go into weeks and 1 and do python
of mario1.py, I'll still get--
in week two.
If I get mario1.py, I still get four question marks.
But that's the result of printing this with a line ending of quote, unquote.
If I do this, meanwhile, it's a little stupid
because I'm going to get that for free if I just omit it altogether.
But now I get four question marks here.
And if you really want to be funky, you can do something
like this, which is just going to be taken literally
to give you that instead.
Unclear utility of taking this approach.
But that's all--
[POPPING NOISE]
Sorry-- that's going on.
Let's take a look at mario2.
This one works a little differently, as well.
And how would you describe the feature offered by this version of mario?
Prints any number of question marks perfectly.
So it's parameterized by first getting and int from the user using
CS50's get_int function.
And now I'm iterating from i to the range of n, whatever that is,
and then actually printing out the question marks.
Meanwhile, in mario3.py, a little fancier still.
But what am I doing a little better now?
AUDIENCE: You're making sure that the n is positive.
DAVID MALAN: Yeah, I'm just making sure that the n is positive.
So I didn't bother implementing a whole function called, like,
get_positive_int.
I don't need that.
This is a super-short program.
I'm just using the same logic up here--
inducing, deliberately, an infinite loop,
breaking out of it only when I've gotten back a positive integer,
and then printing out that many of hashtags, reminiscent of the bricks
in Mario.
And then lastly, we have this slightly more sophisticated version
that actually prints out a different shape altogether.
You can infer from the comments, but focus more on why.
So this first line 12 iterates from i to n,
whatever n is that the user typed in.
Meanwhile, line 15, indented, iterates from j from 0 up to n, as well.
So this is kind of like our canonical for int i
gets 0, dot, dot, dot, for int j get 0, dot, dot, dot, where
we've had nested loops in the past.
So notice now that we have this building block, which is a line of code or kind
of conceptually just a Scratch piece.
We can embed one inside of the other.
Here I can print out a hashtag, making sure
not to put a new line after every single hashtag I print out,
only printing out a new line on line 17, on each iteration of the outer loop.
And now notice whereas in C we would have done this historically--
and that's fine-- in Python, we don't need the f.
And we also don't need the backslash n.
End So ergo, you can simply do print, and you'll get, if nothing else,
a backslash n automatically.
So that now when I run this version of Mario,
we now get something more interesting.
And I'll increase the size of my terminal window
for this so that I can enter a positive number like this and print 10.
And now we've got a whole block.
So that was a lot.
Let's go ahead and take our five-minute break here.
And when we come back, we'll look at some more sophisticated examples still.
All right.
So let's begin to start to transition to actually solving problems with Python
after introducing just a couple of additional features
that aren't so much syntactic but actual features of the language.
So here on the left was an old program we wrote in week three called argv0.c.
And its purpose in life was simply to allow
you to run a command-line argument for the very first time.
And that was a nice tool to have in our toolkit.
So how might we go ahead and map this?
Well, we actually need to know how Python works
a little bit differently as follows.
If I go ahead and open a new file called--
let's call it argv0.py.
I'm going to go ahead and translate this, just as we did earlier.
So I'm going to go ahead and want to use the following.
So if argc-- so there is no argc.
And actually, so def main--
there was also no argc or argv.
And it's not actually correct to do this and this, as you might assume.
It turns out that the feature of command-line arguments
are provided by a Python package, so to speak,
or a library, much like the CS50 library is a package
that you can import in Python speak.
So to do this, I actually need to do this-- import sys, which gives me
access to a whole bunch of system-related stuff,
like what the user has typed at the command prompt.
And if I want to check if the number of words that the human typed
at the prompt is two, I actually am going
to do this-- if the length of sys.argv equals 2,
then I'm going to go ahead and print out quote, unquote, "hello,"
and then a placeholder here.
I know for placeholders, I need to turn this into a formatted string, so
an f string there.
And now inside of the curly braces, it turns out I can do sys.argv[1].
So it's a little different from before.
But notice I'm borrowing almost all the same ideas as earlier,
including how we're printing out strings.
And even though this is a little more verbose,
what is between these two curly braces?
Well it's the result of looking in the system package, which
has a variable called argv, for argument vector,
just like in C. It is itself an array, AKA a list in Python.
And here we have the result of indexing into element one of that list.
And the way that I have access to this is because I've
imported that whole package.
So if on the right-hand side here I go ahead, after saving that file,
and I do python of argv0.py, I see nothing.
But if I actually say, like, my name here, I see, "hello, David."
So a very similar program, but implemented a little differently.
And you'll notice, too, that the length of an array,
henceforth known as a list, is not something that you yourself
have to remember or keep around.
You can just ask a list how long it is by calling the len--
or L-E-N for length--
function, passing it in as an argument.
So that's one of the takeaways there.
And if we actually want to do something a little more clever,
like print out all of the strings in argv, well, back in the day in see,
you might recall this example--
argv1.c, wherein I had this for loop.
And I iterated from zero on up to argc, the argument count,
printing out each of the arguments in that vector.
Python actually makes even something like this even simpler.
Let me go ahead and create a new file here.
And I'll call this, say, argv1.py.
And it turns out in Python, I can similarly just import sys,
and then do, honestly, for s in sys.argv, print s.
Done.
So again, kind of just says what it means.
So I've imported the system library.
sys.argv I know to be a list, apparently, of command-line arguments.
For something in something is a new syntax we have for for loops.
So for some variable s inside of this list, go ahead and print it.
And so it's a much cleaner, much more succinct way
of honestly getting rid of all of the complexity of this
by just saying instead what we mean.
Meanwhile, if I wanted to print out every character,
I can take this one step further.
So back in the day in C if I wanted to print out
every command line argument and every character therein I could do this.
I just need a couple of nested loops, wherein via the outer loop,
I iterate over all of the arguments passed in.
And on the inner loop, I iterate over the current string length
of whatever argument I'm printing.
And this had the effect of printing out all of the command-line arguments'
letters one at a time.
I can do this in Python, honestly, so much easier.
So let me go over here.
Let me create a new file called argv2.py.
Let me import sys, as I did.
So import sys.
And then for s in sys.argv, for c in s, print c.
Done.
So what is this doing?
Gone is all of that overhead of for int i and for int j and so forth.
For s in sys.argv iterates over all of the elements of that list,
one string at a time.
For c in s is a little different because s is technically
a string or a str object, as we're going to start calling it.
But at the end of the day, a string is just a sequence of characters.
And it turns out Python supports, out of the box, the ability to use a for loop
even to iterate over all of the characters in a string.
And so c-- I just mean char.
So for c in s, that gives me each of the characters.
So now at the end here, if I go ahead and run python of argv2.py
with nothing, I get just the program's name
because that's, of course, the very first thing in argv, as in C. And if I
write, say, a word like "Maria" here, I get argv2.py, Maria,
all in one long column because of the additional prints that are happening
and the implicit new lines.
So any questions before we proceed on this use of a package
called sys using these functions therein?
All right.
So let me skip ahead, then, to something slightly familiar, too.
Let me go ahead-- and you might recall initials.c from some time ago,
wherein we accepted as input to get_string a user's name,
and then we printed out their initials.
So let's go ahead and do that.
So from CS50, let me go ahead and import get_string.
Then let me go ahead and say, get me a string.
And I want the user to be prompted for their name, as we might do here.
Then let me go ahead and say, all right, their initials--
I don't know what they are yet.
So let me just initialize an empty string.
But then do this--
for c in s, which is for each character in the person's name, if--
and I don't know how to say this yet.
If c is an uppercase letter, then go ahead and append c to initials.
And then down here, print initials.
So I've left a couple of blanks.
That's just pseudocode for the moment.
But this line 5, just to be clear, is doing what for me?
What is being iterated over?
The string.
So for each character in the string, for c in s, I'm going to ask two questions.
So in C, we did this in a couple of different ways.
We can actually do it with inequality checks
and actually considering what the underlying ASCII values are.
The ctype library had that isupper function and islower that we use.
Well, it turns out because c is itself not a char,
there is no such thing, technically, as a char in Python.
You have only strings of length 1.
And this is why single quotes no longer have any special meaning.
It turns out c is technically just a one-character string.
Strings are what we've started calling objects,
which is a fancier name for struct.
So inside of an object like a string is functionality.
And we saw one piece of functionality earlier, which was what?
Not length, though that is another one.
It was format.
We saw it briefly.
But when I did the string.format, I proposed
that there's actually built-in functionality
to a string called format.
Well, you know what?
It turns out there is a method or function inside of the string
class also called isupper.
And I can ask the very string I'm looking at that question
by saying if c.isupper is true, then go ahead and append c to initials.
So in C, if initials were technically a string,
how could you go about appending another character to a string in C?
AUDIENCE: c.append?
DAVID MALAN: Not in C. In C. So in C, the language.
OK, so what's a string in C?
A string in C is a sequence of characters,
the last one of which is backslash 0.
All right.
So it's an array of characters, last of which is backslash 0.
So if I, for instance, typed in my first name, "David,"
and now I want to append "Malan" to the end of it, how do I do that in C?
AUDIENCE: [INAUDIBLE]
DAVID MALAN: Exactly.
It's like an utter pain in the neck.
You have to create a new array that's bigger, that can fit both words,
copy the "David" into the new array, then copy the last name in, then put
the null terminator at the new array, then free,
probably, the original memory.
I mean, it's a ridiculous number of hoops to jump through.
And you've done this on occasion, especially for things like, perhaps,
problem set five.
But my god, we're kind of past that.
Just go ahead and append to the array the character you care about.
So in this case, not an array, but a list.
Sorry, not an array but a string object that's initially blank.
It turns out that Python supports this syntax--
plus equals typically means arithmetic and add one number to another.
But it also means append.
So you can simply append to initials by doing plus equals c, one
additional character.
So even though the string starts like this, and this big in memory,
it's then going to grow for one character,
grow, grow, grow, grow, until it has all of the user's initials.
And as for where that memory is coming from, who cares?
This is the point that we're now past.
You leave it to the language.
You leave it to the computer to start to manage those details.
And yes, if it needs to call malloc, fine.
Do it.
Don't bother me with that detail.
We can now start thinking and writing code sort
of conceptually at this level, instead of at this level.
So again, we're sort of abstracting away what a string even is
and leaving it to the language itself.
So if I now go ahead and run python of initials.py and type
in, for instance, "Maria Zlatkova" here, with a capital M and a capital Z,
I then see her names because I've plucked out the middle initials.
And if we do something else, like "David J. Malan," even with a period in there,
it infers from the capitalization what my initials should actually be.
So again, a much tighter way of doing things.
Let me go ahead and now open up another example
we didn't see a few weeks ago, though it was
included in some of our distribution code, if you wanted to look.
Some weeks ago, we had this program among the distribution code,
where I declared an array of strings called book.
And I proposed that there were these several names in the phone
book, so to speak-- all of the past instructors of CS50
sorted alphabetically.
And then down below in this C program, I used that global variable called book
to implement, it seems, linear search.
And to implement linear search in C, I'm going to need,
of course, a loop to iterate over all of the strings.
This line 26 does exactly that.
I then in C, recall, had to use str compare
because remember we tripped over this issue
early on where you can't just compare two strings in C
because you'd be comparing, accidentally,
their addresses, their pointers, not the actual value.
So we used str compare.
And I could pass in the name that I'm looking for in the i'th book one
at a time, checking for equals zero.
And then I can call Mike or David or whoever
I'm trying to call, or just quit if the user isn't found.
So what did this program actually do?
If I go into this example, which, again, was from weeks 3,
and I do make linear--
nope, not that.
Wrong directory again.
If I go into source3 and make linear, this program
is supposed to behave as follows.
So if I go ahead and run ./linear, look for our old friend Smith,
it found Smith.
If I go ahead and search for, say, Jones, who did not previously
teach CS50, it says "quitting."
All right.
So meanwhile, in Python, bless its heart, we can get rid of all of that.
And in our source8 directory here and our subdirectory 3,
let me go ahead and open this instead.
In Python, I can declare an array, otherwise known as a list,
almost in the same way.
But what's different, just to be super clear?
AUDIENCE: Brackets?
DAVID MALAN: So the brackets are now square brackets
instead of curly braces.
And frankly, unless you statically initialized an array in C--
like hardcoded the values for your array in C--
you might not have even known you could use curly braces.
So that's not a huge deal here.
But in Python, square brackets here and here represent a list of elements,
literally.
And what else is different?
Didn't declare the size of the array.
And I technically don't have to do that in C,
either, if you're hardcoding all of the values all at once.
But there is something missing on line 7.
AUDIENCE: Type.
DAVID MALAN: Sorry?
AUDIENCE: The type?
DAVID MALAN: The type.
I didn't specify string.
But otherwise, this is pretty similar to what we've done in C.
But what's beautiful here--
and let me go ahead and hide that for just a second.
Let me go ahead and prompt the user for his or her name.
So let's ask for the name here.
And then if I want to search the book, which is just a list of names,
how do I implement linear search?
Well I could just do if name in book, print "Calling name."
And Let's make this an f string.
And then down here, that's it.
So that's how you implement linear search in Python.
You don't need a loop.
You can just ask the question yourself.
So if book is a list, and name is the string that you're looking for,
just ask the language to figure this out for you.
If name in book is the syntax you can use to ask literally that question.
And then Python will use, probably, linear search over that list
because it doesn't necessarily know it's sorted, even
though it happens to be alphabetically.
But it will find it for you, thereby saving us
a lot of the complexity and time of having had to implement that ourselves.
Meanwhile, if I want to compare two strings,
let me propose this-- let me write a quick program here, compare1.py.
And let me go ahead and from CS50 import get_string, as before.
And now let me go ahead and get one string that I'll call s.
And let me get another string that I shall call t,
just as we did a few weeks ago.
And now in C, this was buggy, right?
If I print same, else I print different.
So in C, just to be super clear, why was this incorrect, this general idea
of using equals equals?
Yeah, they're comparing addresses, right?
This was like the day before we peeled back
the layer of what a string actually is.
And it turns out that s and t in C were char stars or addresses, which
means certainly if you get two different strings,
even if you've typed the same characters,
you're going to be comparing two different addresses.
They're not going to be the same.
Now, you can perhaps infer from the theme of today--
what is Python going to do if asked if s and t are equal?
It's gonna answer that question as you would expect as the human.
Equals equals now, in Python, is going to compare s and t,
look at their actual values because they are strings,
and return same if you literally typed the same words.
So in here, if I go in here and I do python of compare1.py, and I type in,
for instance, "Maria," and then I type in "Maria," they're indeed the same.
If I type in "Maria" and, say, "Stelios," they're
different because it's actually now comparing the strings,
as we would have hoped some time ago.
So let's take a look at another that kind of
led to some interesting quandaries.
You might recall in week four, we had this example in C--
noswap, so named because this just did not work.
It was logically seemingly correct.
But swap did not actually swap x and y, but it did swap a and b.
Why?
AUDIENCE: The memory locations?
DAVID MALAN: The memory locations were different, right?
So x and y, recall, are variables in C that exist in a certain slice of memory
that we called a frame on the stack, main's frame on the stack.
Meanwhile, a and b are from a slightly different location in memory.
We sort of kept drawing it slightly above,
like a tray at the dining hall on the so-called stack.
a and b had the same values of x and y--
1 and 2-- but their own copies of them.
So even though we logically, as with Kate, I think,
with the Gatorade, swapped the two values,
we ultimately swapped the wrong two values
without actually permanently mutating the original x and y.
So unfortunately-- well, fortunately and unfortunately in Python,
there is no such thing as a pointer.
So those are now gone.
So we no longer have the expressiveness with which
to solve this problem that way.
But let me propose that we do it in oh-so-clever of another way.
Here let me go ahead and declare x is 1, y is 2.
Let me go ahead and print out as much.
So with a format string, I'm going to go ahead and say x is x, y is y,
plugging in their respective values.
I'm going to do that twice.
But in between, I'm going to try to perform this swap.
And if your mind's ready to be blown, you
can do that in Python, do the old switcheroo in Python.
And this actually does swap the two values as you would expect.
Now this is not a very common case.
And to be fair, this is an incredibly contrived example
because if you needed them swapped, well,
maybe you should have just done this in the first place.
But it does speak to one of the features of Python,
where you can actually do something like that.
Let me introduce now one additional feature that we only recently
acquired in C. And that's the notion of a struct.
And let me go ahead and do this in code from scratch.
So let me go ahead and save this file proactively as struct0.py,
reminiscent of one of our older programs.
And let me go ahead and do this.
From CS50 import get_string.
And then let me give myself an empty list.
So that would be a conventional way of giving yourself
an empty list in Python.
And much like in C, you can declare an empty array.
But in C, you have to know the size of it
or, if not, you have to use a pointer.
And then you have to malloc.
No.
All of that is gone.
Now in Python, you want a list?
Just say you need a list.
And it will grow and shrink as you need.
Now I'm going to go ahead and just three times, arbitrarily,
for i in the range of 3, let me go ahead and ask
the user for a name using get_string.
And I'll ask him or her for their name.
Dorm will use get_string, as well.
Dorm here.
And then I want to append to the array this student.
So I could do something like this-- students.append name.
And it turns out-- and we've not said this yet.
But there is inside of the list data type a method--
that is function-- built into it called append that literally does that.
So if you've got an otherwise empty list,
and you calls that list's name dot append,
you'll add something to the end of the list.
And if there's not enough memory for it, no big deal.
Python will find you the memory, allocate it, move everything in it,
and you move on your way without having to worry about that.
But I don't want to store just the name.
I want to store the name and the dorm.
So I could do this.
I could do-- well, maybe this isn't really students.
Maybe this is now, like, dorms.
And then here I could do dorms.append dorm.
But why is this devolving now into bad design
if my goal was to associate a student with his or her dorm,
and then keep those values together?
Why is this not the best approach in Python or, back in the day, even in C,
to have two separate arrays?
AUDIENCE: Like struct?
DAVID MALAN: What's that?
AUDIENCE: Struct?
DAVID MALAN: Well, it's twice as many things to maintain, for sure.
And what else?
AUDIENCE: You can't map them to each other.
DAVID MALAN: You can't map one to the other.
It's just-- it's very arbitrary.
It's sort of this social contract that I will just
assume that student 0 lives in dorm 0.
And student 1 lives in dorm 1.
And that's fine.
And that's true.
But one of the features of programming and computer science
is this idea of encapsulation, like, associate related memory
with each other.
And so what did we do in C instead?
We did not have two arrays.
AUDIENCE: We had a struct.
DAVID MALAN: Yeah, we had a struct.
And so Python doesn't have structs per se.
It instead has what are called classes.
And it has a few other things like tuples and namedtuples,
but more on those some other time.
So it turns out I could actually implement my own notion of a student.
And I could import it like this.
The convention in Python is if you create your own struct,
henceforth called a class, you capitalize the name of it
by convention.
So a little different from C conventions.
So what is a student going to look like?
This is perhaps the most complex syntax that we'll have today,
but it just has a few lines.
If you want to implement the notion of a student, how might you do this?
Well, in Python, you literally say class Student,
where class is similar in spirit to-- just to be clear--
struct or typedef struct.
But in Python, we're just saying class.
And then this is the funky part.
You can declare a function that by convention must be called init
for initialize that takes as its first argument a keyword called
self, and then any number of other arguments like this.
And then, for reasons that will hopefully be clear momentarily,
I can write some code inside of this method.
So long story short, what am I doing?
I have declared a new type of data structure called Student.
And implicitly inside of this data structure,
there are two things inside of itself--
something called name and something called dorm.
And this is how you would in a C struct typically do
things with the data types and semicolons inside of the curly braces.
Meanwhile, there's this method here.
And it's a method insofar as it is inside of a class.
Otherwise it's a function, just by a different name.
This method init takes whatever self is-- more on that another time.
But it then takes zero or more custom arguments that you can provide.
And I called it name and dorm.
So it turns out this special method init is
a function that's going to be called automatically for you any time you
create a student object.
So what does that actually mean?
That means in your code, what you can actually do is this.
I can create a student in memory by saying s gets capital Student, passing
in name and dorm.
And we don't have this feature in C.
On the right-hand side, what I've highlighted
is the name of the class and its two arguments--
name and dorm, which are just what the user has typed in.
What this class does for me now is it allocates memory
underneath the hood for a Student.
It's got to be big enough for their name and big enough for their dorm.
So it's, like, yay big in memory, so to speak.
It then puts in the name and the dorm strings into that object,
and then returns the whole object.
So you can kind of think of this as a much fancier version of malloc.
So this is allocating all the memory you need.
But it's also installing inside of that memory the name and the dorm.
And it's bundling it up inside of not just an arbitrary chunk of memory,
but something you can call a Student object.
And all that means that now for our students,
we can just go ahead and append that student to the list.
So now if later I want to iterate over for student in students,
I can go ahead and print out, for instance, that student.name
lives in student.dorm, close quote.
And if now over here--
whoops, close that.
Now over here, if I go ahead and run python on struct0.py--
oh, no!
Oh, thank you.
That goes there.
So now-- dammit.
Missing curly-- oh, thank you.
OK.
So now if I want to go ahead and type "Maria" and "Cabot" and "David"
and "Mather" and "Rob" and, say, "Kirkland," now we get all three
of those names.
And there's other ways, too, if we wanted
to actually store this thing on disk.
But I'll defer that to an example online.
Let's look at one final example that will hopefully
either make you regret the past several weeks
or embrace the next several instead.
So you'll recall that--
though the former, I suppose, could be true even without my help.
So if I go into now today's distribution code, you will see this program.
And we won't walk through all of its lines.
But this is a program written in Python called speller.
And what I did was literally sit down with speller.c from problem set 5.
And I just converted it from left to right, from C to Python,
implementing it in Python in as close to an identical way as I could,
just using features of Python.
So just skimming this, you'll see that apparently my implementation of speller
in Python has a class called Dictionary which is very similar in spirit
to dictionary.h in C Notice that I still have a constant here.
Or it's not technically a constant, but a variable called length equals 45.
I hardcoded in dictionary/large, as speller.c did, too.
I'm using command-line arguments, as we saw earlier,
but this time in Python instead of C.
Notice you can do funky things like this,
which is reminiscent of our swap trick just a little bit ago.
If you want to declare multiple variables all on the same line
and initialize them, you can just enumerate them all with commas.
Then on the other side of the equal sign,
enumerate with commas the values that you want to assign to those variables.
And then down here, if I keep scrolling, you'll
see code that we won't get into the weeds of, but some familiar phrases.
So this is the program that actually runs a student's dictionary
on some input, and then prints out per all of this stuff at the bottom
all of the familiar phrases that you might recall from problem set five.
So this took a lot of work, most likely, to implement in C. And understandably,
you might have used a linked list initially,
or ultimately you might have used a hash table or a try
or struggled with something in between those two.
And that is a function of C. C is difficult.
C is challenging because you have to do everything yourself.
An upside, though, of it is that you end up getting a lot of great performance,
theoretically.
Once you have implemented the code, you're kind of as close to the hardware
as possible.
And so your code runs pretty darn well and is dependent
only then on your algorithms, not on your choice of language.
So here let me go ahead and implement a file called dictionary.py.
And let me propose that the words--
the equivalent, sorry, of dictionary.h would be this file here.
And it's going to have a function called check,
which takes in an argument called word.
It's going to have a function called load, which
takes in an argument called dictionary.
It's going to have a method called size, which takes
in no arguments other than itself.
And then it's going to have a method called unload,
which also takes no arguments other than itself.
So if we were instead to have assigned problem set five in Python,
we essentially would have given you a file called dictionary.py
with these placeholders for you because recall in pset five,
those were all to dos.
Strictly speaking, there would be one other here.
We would probably have a def init because every class in Python,
we'll see, we'll typically have this init method,
where we just are able to do something to initialize the data structure.
So let me go ahead and do this.
We don't know that much Python yet.
And we're taking for granted that speller in fact, works.
But let me go ahead and load some words in a dictionary.
So here is my method called load.
Dictionary is going to be the name of the dictionary to load.
So you guys implemented this yourself by loading those files from disk.
In Python, I'm going to do this as follows.
Give me a file and open it in read mode.
Iterate over each line in the file.
Then go ahead and add to my set called words
the result of that line by stripping off the end of it backslash 0.
Then go ahead and close the file, and then return true
because I'm done implementing load.
So that is the load method in Python.
Happy, yes.
OK.
So check.
Check was a struggle, too, right?
Because once you had your hash table, or once you had your try, now
you had to actually navigate that structure in memory,
maybe recursively, maybe iteratively, following lots
of pointers and the like, following a linked list.
How about I just do--
let's just say if word lowercase in self.words, return true.
Else return false.
Done.
So that one's done.
Size-- we actually can kind of infer how to do this.
Return the length of the words.
That's done.
Unload-- don't have to worry about memory in Python, so that's done.
And there you have a problem set five.
[APPLAUSE]
Thank you.
So what then are the takeaways?
Either great elation that you now have this power or great sadness
that you had to implement this first in C. But this was really
ultimately meant to be thematic.
Hopefully moving forward, even if you struggled with any number of these
topics-- linked lists and hash tables and pointers and the like--
hopefully you have a general understanding
of some of these fundamentals and what computers
are doing underneath the hood.
And now with languages like Python and soon with JavaScript and SQL,
with a little bit of HTML and CSS mixed in for our user interfaces,
do you have the ability to now solve problems,
taking for granted both your understanding of those topics
and the reality that someone else has now implemented those concepts for you
so that when it comes to solving problem sets six and seven and eight,
and then leaving CS50 and solving problems in your own domain,
you have so many more tools in your toolkit.
And the goal really for you is going to be to pick
whichever one is most appropriate.
So let's adjourn here.
I'll stick around for questions.
And we'll see you next time.
Best of luck on the test.