Django is an MVC, or model-view-controller framework, but Django doesn't call

templates views or the functions that return rendered templates controllers.

Instead, Django calls templates templates, and

the functions that return rendered templates views.

This can be a little bit confusing,

but you get used to this nomenclature really quickly.

It you've already done my Flask courses, you're probably used to it already.

So, to get our very own Hello World, we need to create a new view and

give it a URL.

Are your ready?

If we look in our learning site Stub, this little thing right here,

we see that we have this settings.py file, and let's look in there.

It's just a bunch of stuff you can look at, nothing super important just yet.

We'll wanna change some things later.

Anyway, though, inside of here we don't have a views.py file.

Or, if you've done a lot of Flask you might be looking for an app.py,

something like that.

We don't have anything like that.

All we have are settings, URLs, and our WSGI, our server interface.

The little Stub doesn't have a whole lot of functionality for our project.

But, this is really the easiest place for us to add just a simple view.

So, let’s add a views.py file in here to hold our view.

So we’ll do views.py.

There’s nothing in there.

We need to do an import and then create a function.

So the import we need to do from django.http import HttpResponse.

And then, we're gonna do a def hello_world and it's going

to take a request or an argument that we're going to call a request,

and it's going to return the HttpResponse that we imported.

Capital letters let you know that it's a class.

And we're just gonna return the string hello_world.

So we're gonna save that.

So, HttpResponse that comes from Jenga's http library is a class that lets us make

well, http responses.

The response is a really, very malleable.

Most of the time,

though, you're gonna have more specific responses that you want to send back, so

you're gonna send back specifically a certain error, or a redirect, or whatever.

But, for right now this is all we need.

So, we have our function that takes a single argument called request.

Call it whatever you want but calling it request is a pretty common standard.

It's a good idea to do that because that's what it is.

It's the request.

It's what the client has sent to your server that's made it all the way to

Django We don't need it for this view.

We're not gonna do anything with the request.

But all views have to accept the request, so we have to put it in there.

Most of the time, you'll likely end up using it one way or the other.

Finally, in our view, we create an return our HttpResponse.

And we've given it a string as an argument.

This'll put that string as the body of the response.

Okay, let's go see this live.

Wait a minute, we have to do one more thing.

We have to give it a URL route.

I know that seems like a lot of work for

nothing, but this a process that we'll be doing a lot in this course and

that you'll do repeatedly in your future work with Django.

So I think it's worth spending some extra time on, don't you?