[MUSIC]

[SOUND] >> Templates in Django are a lot like

templates in Flask.

If you're not familiar with the idea of a templating system,

it usually involves a few parts.

Templates are usually HTML that has special tags or commands in it.

These tags let you print out data, create loops and conditionals,

and perform other programming constructs.

Templates are also often inheritable, or extendable.

So you can write small templates that fit into larger ones to save yourself trouble.

In Django, templates can be any language that you want.

HTML, JSON, XML, or something else entirely, they just have to be text.

We're gonna be creating HTML templates though,

because we want to give our users pages to look at in their browsers.

So the first template that I want to make is one for

the course list view that we just made.

You remember looking over here in views.py.

What we have right now is fine, I mean, it lists out the names.

But, it's not really useful.

So, let's fix that.

Now, by default, Django looks for

a templates directory inside of your app directory.

And we don't have one so we need to make one.

So here in courses we're gonna make a new folder, and we're gonna call it templates.

Now, it also expects inside templates that you'll have a folder or

directory with the same name as your app.

So, New Folder, courses.

So we have courses > templates > courses.

Now the reason that we do this is so that we have all of

our app-specific templates inside this namespaced directory, courses.

And then if we need to let people override them,

they just make their own template directory named courses.

Or, if we want to have templates that are for

multiple sections, we could name them different names, whatever.

Anyway though, it's a really nicely done namespaced way of handling templates.

Okay, so now, inside courses > templates > courses, I'm gonna make a new file

that is named course_list.html, because it's the list of courses.

Now of course, it doesn't have to have the same name as our view, it just happens to.

And I kind of like for them to have the same name so

that I know this template goes to this view.

And I like my names to be done like this, course_list,

because I know that it's a list of courses.

So kind of two ways for me to go, okay, that's what this thing is for.

Now if we were doing one that was only gonna show a single course,

then we might call it course_detail.

Or maybe it was a form for creating new courses,

maybe it's course_create or course_form, something like that.

But like this, we know that it's a list of courses.

Cool.

Obviously, by default, since we just created a file, our template is blank.

So let's put in just a little bit so we can see the titles and

the descriptions of our courses.

We'll decide here that we're gonna provide a list to our template, and

that list will have all the courses.

Django let's us do for loops in our templates, so let's see by doing that.

So we can do for course in courses, and

then we have to end our for loop with the endfor tag.

So now anything that we have in here will get done once for

every course that's in our courses list.

Template tags are the things that let us use little bits of Python in

our templates.

And they always start and end with a pair of characters,

which is the curly brace and the percent sign.

Django's template engine isn't quite as free-form as the Jinja2 template system

that we've used in the Flask course, but you can still do a lot with it.

And actually in Django 1.8 it's also possible to use Jinja2 for

rendering your templates.

But we're not gonna cover that in this course,

we're gonna stick with Django's template renderer for this course.

Okay, so inside this loop we want to print out the title of the course and

the description of the course.

We use two curly braces to print out a variable.

So let's make an h2, and inside of the h2 we'll print course.title,

and then below that we'll print out course.description.

Now since the fields belong to the model instance as attributes,

we access them with the dot, just like we would if we were looking at an object in,

like our shell.

And then we have to end our for loop, which we've already done.

All right, so let's go make our view use our template.

So this is our template.

For course in courses, print out the title, print out the description.

Done, all right, views.py.

What we're gonna do is we're gonna get rid of most of this work.

We don't need this output, and we don't need this return.

So let's get rid of those.

And we're gonna return a new thing, we're gonna return the render function.

And look at that, we've already got it imported.

And so this takes three arguments that we need to give it right now.

So first of all it takes the request object,

this thing that comes in right here.

So it takes that, and then it takes the template to render.

Now, we're going to say 'courses/course_list.html'.

And then, optionally, it takes a dictionary.

We call this dictionary a context dictionary,

because it's the context with which the template will be rendered.

And we're going to provide it a key named courses, and

it's going to be our thing we picked up earlier named courses.

This right here, it's all of our courses.

So, we've got all this stuff.

There are some other arguments that render can take,

I'll link to more information in the teacher's notes.

But for here though we're just handling this fairly simple, straightforward use.

So we need to run our server.

If your server is already running, you won't have to do that.

Mine died, so I had to restart it.

And then if I come back over here and I look at courses, check that out.

That looks, well, maybe not great, but it looks okay.

So, this covers, I mean this is creating a template for

an app, that's fairly straightforward.

But what if I wanted to have a layout for

the homepage, the page that we made, let's go look at it here.

Page that we made over here, this hello_world.

The one that we get by just going to forward slash.

What if I want a template for this page?

Its view doesn't live inside of an app.

So we can't just add a template's directory to an app and be done with it.

We could have template for it to our courses app, but that doesn't make a lot

of sense because that page may not come with our courses app.

So, how do we handle this?

Well, what we're gonna do is we're going to add a directory.

Let's close this stuff up here.

We're gonna add a directory into our outermost learning site here, and

we're gonna name this directory templates.

And we have to go do one more thing.

So we have to go change our settings.

So let's go look at our settings.

Here's our settings, and we're gonna come down here, and we've got templates.

And then we've got this list here called DIRS.

So this templates thing here is a list, and each item on the list is a dictionary,

and each of those dictionaries describes one way of rendering templates.

So for instance, this one is the BACKEND that renders Django templates,

this is just the Django templates renderer.

This is where we had change to like the Jinja2 template renderer.

And this APP_DIRS directory here is the one that says look for

templates directories inside of apps.

That's what lets us do the templates courses thing, so that's pretty cool.

Options, these are just different things that you can configure per template

renderer.

Some of them you don't want to have debugged, maybe you don't want to have

the request object, maybe you don't want to have messages, whatever.

What we care about though, is this DIRS list.

So this DIRS list lets us specify other

directories that we want included for it to go look for templates in.

So, this actually works from the root of the site.

So this is the root of our site.

So how do we find in here the directory?

Well, we named the directory templates, so let's just add in the string, templates.

And I'll put a comma in there because that's a good habit.

Okay, so now we need to create our template, and our view,

and change our view.

So let's make a new file here, and we'll call it,

say, home.html, since it's the homepage.

And then, inside here I'm gonna put an h1 and it's just gonna say welcome.

And I think that's good enough for now.

So it just says welcome.

I mean, right now, it says, Hello World, we'll say, welcome.

So, now let's go back and edit our views.

So here's our views.

And what we need to do is we need to change this to shortcuts, and render.

And then we're going to return render (request,

and our template is 'home.html').

And we don't have to give a directory on this one because it doesn't live inside

of another directory.

We could have added say, default or basic or whatever, but

this one doesn't live inside anything.

And then we don't have to include the context directory, or

dictionary because there's no context.

Okay, so let's refresh this.

And we get our Welcome, great.

You might want to change the view name from, hello_world, to, home or home_page.

Be sure you change the URL too, since it has the view name in it.

In our next video,

we'll look at the other important part of a templating system, template inheritance.