DAVID MALAN: All right.

This is CS50.

Welcome back to all.

And this is one of those rare days, where, in just a couple of hours,

you'll be able to say that you've learned a new language.

Or if you have a little bit of Python background already,

you'll be able to say hopefully that you know it all the more,

because even though we've spent the past several weeks focusing on C,

one of the overarching goals of the class is not to teach you C--

and indeed, C is officially now behind us--

but really to teach you how to program.

But realize, too, that even as we dive into a new language today,

the goal is not to take a course on one language or another.

Indeed, I, myself, back in the day took CS50 and just

one other follow-on class, where I learned how to program.

And every language since then have I pretty much

taught myself, learned from others, learned by reading other code,

and really bootstrapping myself from that.

So after just this term, hopefully will you

have the power to teach yourselves new languages.

And today, we start that together.

All right.

So where do we begin?

Back in week 0-- this is, recall, where we began,

just making a little cat on the screen say "Hello world."

And very quickly, things escalated a week later

and started looking like this.

Now, hopefully, over the past several weeks,

you've begun to see through the syntax and see the underlying concepts

and ideas that actually matter.

But even so, there's a lot of cognitive overhead.

There's a lot of syntactic overhead just to getting something simple done

in this language called C.

So starting today, we're going to introduce you

to another programming language called Python

that has been gaining steam in recent years and is wonderfully applicable,

not only for the sort of command line programs

that we've been writing in our terminal windows,

but also in data science applications, analytics of large data sets,

web programming, and the like.

So this is the type of language that can actually solve many problems.

And wonderfully, if we want to say "Hello, world"

starting today in this new language, Python, all we need type is this--

typing the commands that you actually ultimately care about.

So how do we get to that point ultimately?

Well, recall that in C, we had this process of compiling our code and then

running it, as with make or more specifically, as with clang,

and then running it with the file ./hello,

representing a file in your current working directory.

Today, even that process gets a little easier

in that it's no longer a two-step process to write and run code.

It's now just one.

But it's a little bit different from the past, whereas in the past,

we've, indeed, compiled our code from source code into machine code and then

done ./ in order to run it.

Just as in a Mac or PC, you would double click an icon,

Python is used a little differently.

And other languages are used in the same way, too.

You don't run the programs directly per se.

You instead, literally, starting today, run a program

that itself is called Python.

And you pass as input to it the name of the file containing your source code.

So Python itself is the program.

It supports command line arguments.

And one of those arguments can be the name

of your very program, which means we don't have to very annoyingly keep

compiling and recompiling our code every time we make a change.

If you want to make a change to your code, all you need do

is save your file and rerun this command.

So let's put this into context.

Let me go over to CS50 IDE, which for Python, you can continue using,

as well.

Let me go ahead and create a new file called, for instance, hello.py.

So instead of hello.c, I'll use hello.py--

py being the convention for Python-based programs.

And you know what?

If I want to print "hello world," I'm just going to go ahead and say

print("hello, world").

I'm going to go ahead and save my file.

And then, in my terminal window, there's no need to compile.

I can now run the program called Python, which is identically

named to the language itself.

And I'm going to go ahead and run the file called hello.py

as input into that program.

And voila, my very first program in Python.

No curly braces, no int, no main, no void, no include--

you can just start to get real work done.

But to get more interesting real work done,

let's start to bootstrap things from where we left off

when there are comparisons between Scratch and C,

doing the same thing, again, this time between Scratch and C,

but now Python, as well.

So in the world of Scratch, if you wanted to say "hello, world,"

you would use this purple block, a function, as it was called at the time.

And we translated that a few weeks back now to the corresponding C code--

printf("hello,world").

And there were a few nuances and things to trip over.

It's printf.

It's not print.

You've got the backslash n and the semicolon.

Today, in Python, if you want to achieve that same goal,

as I just did in the IDE, you can simplify this to just that.

So just to be super clear, what has changed from C to Python?

What do you no longer need to worry about in Python--

some observations?

Yeah.

AUDIENCE: Semicolons.

DAVID MALAN: No more semicolons-- those are officially gone.

Other comments?

AUDIENCE: No more new lines.

DAVID MALAN: No more new lines--

print will actually give you one if you simply call print.

Let me go over here.

AUDIENCE: Print instead of printf.

DAVID MALAN: And it's print instead of printf and--

this is going to end poorly today, because my arm will eventually fail.

Are there any other differences that jump out?

Maybe?

AUDIENCE: No more standard I/O.

DAVID MALAN: No more standard I/O--

so there's none of the overhead that we need.

I'm not going to give you a stress ball, though, from that one

just because it wasn't in the previous slide for C.

But indeed, there's no overhead needed, the includes

and so forth, just to get real work done.

AUDIENCE: No backslash [INAUDIBLE].

DAVID MALAN: Oh, that was taken already.

So I'm sorry.

The stress ball's again given out.

Yeah.

AUDIENCE: No %s.

DAVID MALAN: No %s, but not germane fear,

because I'm not yet plugging anything in.

So, in fact, let me just move on, because I'm

pretty sure there's no other differences or stress balls for this one.

So let's take a look, though, at a variant of this,

where we wanted to do something more interesting than just print

statically-- that is, hardcoded-- the same thing again and again--

hello, world-- something like this.

And now, I'll come back to you in just a moment.

If you want to get users' input, in Scratch, we use this Ask block.

That gave us access to a special return value or variable called answer.

And then, we could use "join" and creatively

use the Say block to concatenate, or join those two values together.

In C, this ended up being this, where you declare a variable on the left.

You assign it the return value on the right, as with the first line there.

And then, you go ahead and print out not just hello.

But hello, %s, which then plugged in that value.

In Python, you can achieve the same goal.

But it's going to be a little simpler.

We can now do it with just this.

So what has disappeared clearly from the screen?

What do we no longer need to worry about in Python?

Yeah.

AUDIENCE: Well, you could just do plus answer instead of, like,

having to do it with a comma and the %s answer.

DAVID MALAN: Exactly.

So there's no %s.

We're just using this comma operator, which is new in Python.

This is actually now called the concatenation operator.

And if you've studied Java or a few other languages,

you know that this will join the string on the left

with the string on the right.

So we can sort of construct this phrase that we want.

And because you called out the %s earlier--

AUDIENCE: Oh.

DAVID MALAN: --let me be fair there.

Yeah.

AUDIENCE: We didn't have to identify answer as a string.

DAVID MALAN: Good.

We don't have to identify answer, which is, indeed, our variable as a string,

because even though Python will see has data types--

and it does know what type of value you're storing--

you don't have to, pedantically as the programmer, tell the computer.

The computer can figure it out from context.

Any other distinctions?

AUDIENCE: No semicolons.

DAVID MALAN: No, no, semicolons, as well,

and I was hoping no one would raise their hands from farther away.

But here we go.

Oh.

[LAUGHTER]

OK.

My bad.

Good.

Good.

Good.

OK.

So there's a few differences, but the short of it

is that it's, indeed, simpler this time.

Indeed, I don't need the %--

the backslash n either, because I'm going to get that for free.

So let's fly through a few other comparisons, as well, not just

on the string here or here, but now using a different approach.

It turns out that you can use print in a few different ways.

You can, indeed, just concatenate one string with another

by using that plus operator.

Or if you read the documentation, it turns out

that print takes multiple arguments.

So the first one might be the first word you want to say.

The second argument might be the second thing you want to say.

And by default, what print will do, per its documentation,

is automatically join, or concatenate those two strings

automatically by adding a space.

So it's not a typo that I removed the space after the comma.

I'm going to get that for free, so to speak,

because print is going to do that for me.

Now, this one's about to be a little ugly.

But it's an increasingly common approach in Python to do the same thing.

And it's a little more reminiscent of C. But it turns out

we'll see over time it's a little more powerful.

You can also achieve the same result like this.

All right.

So it's a little weird looking.

But once you start to recognize the pattern, it's pretty straightforward.

So it's still the function print.

There's still a double quoted string, though it turns out

you can use single quotes, as well in Python.

Answer is the variable we want to print.

So what's new now is these curly braces, which say interpolate the value

in between those curly braces-- that is, substitute it in just like %s works.

But there's one more oddity, definitely worthy of a stress ball

here, that's not a typo, but does distinguish this from C. Yeah.

AUDIENCE: The f.

DAVID MALAN: The f-- and this is one that-- here you go--

the weirdest features of-- oh, my bad.

[LAUGHS]

This is one of the weirdest things about recent versions of Python

in recent years.

This is what's called a format string, or f string.

If you don't have this weird f in the beginning of the string immediately

to the left of the double quotes, you will literally print on the screen

H-E-L-L-O comma space curly brace ANSWER curly brace.