This is CS50, and this is week 8.

So for the past several weeks have we been focusing on first Scratch

and then C. And now today do we introduce another language altogether,

that of Python.

Indeed, even though we've spent all this time talking about C--

and hopefully understanding from the ground floor

up what's going on inside of a computer and how things work--

the reality is that C is not the best language with which

to solve a whole lot of problems.

|ndeed, as you yourselves might have realized by now,

the fact that you have to manipulate sometimes memory at its lowest level--

the fact that any time you want to get something real done,

like add capacity to a data structure or grow a string,

you have to do all of that work yourself--

means that C really creates a whole lot of work for the programmer.

But ever since C's invention many years ago

has the world developed any number of new languages--

higher level languages, if you will-- that

add on features, that fill in gaps, and generally

solve problems more effectively.

And so today, we start to do exactly that transition,

having motivated this just a week ago with our look at machine learning.

Indeed, one of the tools that we use to have that conversation

was to introduce snippets of this language, Python,

because indeed it is much more of a well-suited tool than something like C.

But let's begin this transition now.

We, of course, started this conversation many weeks ago

when we looked at Scratch.

And yet even though you probably found it pretty fun, pretty friendly,

and pretty accessible, the reality was that built into Scratch

was quite a lot of features, loops, and conditions,

and customized functions, and variables, and any number of other features

that we then saw the week after in C-- albeit a little more

arcanely with more cryptic syntax.

But the expressiveness of Scratch remained within C.

And indeed, even today, as we transition to another language altogether,

you will find that the ideas remain consistent.

And indeed, things just get easier in many ways to do.

So we transitioned to C. And today we transition to Python.

And so let's, just as we did with Scratch,

try to convert one language to another, just

to emphasize that fundamentally the ideas today are changing, simply

the way of expressing it.

So this perhaps was the very first program

we looked at in C-- arguably the simplest,

and yet even then there was quite a bit of overhead.

Well, starting today, if you wanted to write a program that does exactly that,

voila!

In Python, you simply say what you mean.

If you want to print "hello world," you literally in a Python program

are going to write print open parenthesis quote unquote,

"hello world."

And you can even omit the semi-colon that might

have hung you up so many times since.

Now in reality, you'll often see a slightly different paradigm

when writing the simplest of programs.

You might actually see some mention of main.

But it turns out that a main function is not actually required in Python

as it is in C. Rather, you can simply write code and just get going with it.

And we'll do this hands-on in just a bit.

But you'll find that a very common paradigm

is to actually have code like this, where you do,

in fact, define a function called main.

And as we'll soon see through quite a few examples,

this is how now in Python, you define a function.

You literally say "def" for define, "main"

if that's the name of the function, open paren, close paren, and maybe

zero or more parameters therein, and then a colon,

and an absence of the curly braces-- with which you might now

have gotten so familiar.

But then indented beneath that, generally four spaces here,

would be the code that you want to execute.

And we'll come back to this before long.

But this is just a common paradigm to ensure

that at least one function in a Python program is called by default

and by convention, we'll see-- it's called main.

But the reality is that the program can now be as simple as this.

So let's distill some of the fundamentals

that we first saw in Scratch, then saw in C, and now see in Python as well.

So Python has functions and it also has something called methods-- but more

on that when we talk about object-oriented programming.

But a function in C for printing "hello world" might have looked like this.

Notice the printf for printing a formatted string.

Notice the backslash n that's inside there.

Notice the semi-colon.

In Python, it's indeed going to be a little simpler.

We can distill that to just this.

So we're not going to use printf, we're just going to use print.

We don't, it turns out, have to have the backslash n in this example.

You're going to get that for free.

Just by calling print are you going to get a trailing newline printed.

And we don't, again, need the semi-colon at the end.

Well, what about loops?

Well, in Scratch, we had the repeat block.

We had the forever block and some other constructs still.

In C, we had things like for loops and while loops and do while loops.

Well, let's do a couple of conversions.

In C, if you wanted do something forever, like print "hello world" again

and again and again, never stopping, one per line,

you might use a while loop like this.

In Python, you're going to do something pretty similar in spirit,

but it's going to be formatted a little differently.

We still have access to the while keyword.

The boolean value true now has to be capitalized with a capital T.

And again, instead of using curly braces,

you're going to use a colon at the end of this statement

and then indent all of the code beneath it that you want to happen cyclically.

And again, we've borrowed print "hello world" from before,

so no semi-colon necessary there.

No f and no backslash n is required.

Meanwhile, if we had a for loop in C that we

wanted to say print "hello world" 50 times,

we might use a fairly common paradigm like this.

Well, in Python you can do this in any number of ways.

But perhaps one of the most common is to do something like this,

to literally say for i in range 50-- more on that in just a moment--

and then print "hello world."

So this is shorter hand notation.

And this is perhaps the first instance where you really see just how pedantic,

how much C belabors the point, whereas in Python you

just probably with higher frequency just say what you mean.

So for implies a looping construct here. i

is declaring implicitly a variable that we're about to use.

And then what do you want i to be?

Well, you want it to be in a range of values from 0 up to but excluding 50.

So you want to go from 0 to 49, effectively.

And the way you can express that here is as follows.

You call this range function, which gives you

essentially a sequence of numbers starting at 0, and then 1, and then 2,

and then 3-- all the way up to 49.

And on each iteration of this loop does i get assigned that value.

So functionally, what we've just done is equivalent to what

we've just done here, but it does it in a more Pythonic way, if you will.

We don't have access to that same for construct

as we did in C. We actually have something

that's a little easier, once you get used to it, to use.

Now how about variables?

Well, recall that in Scratch, we had variables, those little orange blocks.

And we didn't have to worry about the type.

We could just put in numbers or other such things into them.

And then in C, we had to start caring about this.

But we had booleans, and we had floats, and we

had doubles, and chars, and strings, and longs, and a few others still.

Well, in Python, we're still going to have a number of data types.

But Python is not nearly as strongly-typed, so to speak,

whereas in C-- and languages like C and a few others--

you have to know and care about and tell the compiler what type of value

some variable is.

In Python, those types exist.

But the language is more loosely-typed, as we say, whereby they have types,

but you as the programmer don't have to worry about specifying them,

a bit more like our world from Scratch.

So whereas in C, we might have declared an integer called i and assigned

it an initial value of 0-- we might have used syntax like this.

In Python, it's going to be similar in spirit, but a little more succinct.

Again, just say what you mean. i gets zero

with no semi-colon, no mention of the type.

But insofar as Python supports numbers, it's

going to realize-- oh, that zero looks like an integer, is an integer.

I'm going to define, ultimately, i as of being of type int.

Meanwhile we have boolean expressions in Python as well.

And these actually translate perfectly.

If you have an expression in C testing whether i is less than 50,

this is the same thing in Python as well.

You literally use the same syntax.

If, instead, you want to generally compare two variables, just

like we did a few weeks back in C, you might

do x less than y-- same exact code in Python as well as in C.

Now how about conditions?

So conditions are these branching constructs

where we can either go this way or maybe this way or another way.

So it's the proverbial fork in the road.

Well, in C, if you wanted to have an if statement that

has three different branches, you might do something like this.

And as you may recall, these curly braces

are not strictly necessary, simply because we

have one line of code nested beneath this if, and one line of code

beneath this else if, and one line of code beneath this else.

Technically, and you might have seen this in section or other resources,

you can actually omit all of these curly braces, which to be fair,

makes the code look a little more compact.

But the logic is pretty straightforward.

And we saw similar yellowish blocks in Scratch.

Now in Python, the idea is going to be exactly the same,

but some of the syntax is going to be a bit different.

So if we want to say, is x less than y, we still say it,

but we don't need the parentheses.

In fact, if they don't add anything logically,

we're just going to start omitting them altogether as unnecessary.

We do have the colon, which is necessary at the end of the line.

We do have consistent indentation.

And those of you who have not necessarily

had five for fives for style, realize that in Python the language by design

is going to enforce the need for indentation.

So in fact, I see myself being a little hypocritical here, as I inconsistently

indent this actual code.

So this would not actually work properly,

because I've used a variable amount of spacing.

So Python is not going to like that.

And in fact, that's why I made that mistake to make this point here,

so that you actually have to conform to using four spaces or some other,

but being consistent ultimately.

So notice this.

This?

Not a typo.

I didn't make that many mistakes here. "elif"

is actually the keyword that we use to express "else if."

So it's simply a new keyword that we have in Python,

again, ending the same line with the colon.

And then here, logically, is the third and final case.

else, if it's not less than and it's not greater then,

it must in fact be equal to.

So we've used print as before to express these three possible outputs.

What about things like arrays?

Well, Scratch had things called lists that we essentially

equated with arrays, even though that was a bit

of an oversimplification at the time.

Python also has effectively what we've been using and taking