The data in a Django project is structured as a set of Users interact with a project through web pages, and a

models. projects home page can start out as a simple page with no
data. A page usually needs a URL, a view, and a template.
Defining a model
To define the models for your app, modify the file models.py that Mapping a projects URLs
was created in your apps folder. The __str__() method tells The projects main urls.py file tells Django where to find the urls.py
Django how to represent data objects based on this model. files associated with each app in the project.
from django.db import models from django.conf.urls import include, url
from django.contrib import admin
Django is a web framework which helps you build class Topic(models.Model):
interactive websites using Python. With Django you """A topic the user is learning about.""" urlpatterns = [
define the kind of data your site needs to work with, text = models.CharField(max_length=200) url(r'^admin/', include(admin.site.urls)),
and you define the ways your users can work with date_added = models.DateTimeField( url(r'', include('learning_logs.urls',
that data. auto_now_add=True) namespace='learning_logs')),
]
def __str__(self):
return self.text Mapping an apps URLs
Its usualy best to install Django to a virtual environment, An apps urls.py file tells Django which view to use for each URL in
where your project can be isolated from your other Python Activating a model the app. Youll need to make this file yourself, and save it in the
projects. Most commands assume youre working in an To use a model the app must be added to the tuple apps folder.
active virtual environment. INSTALLED_APPS, which is stored in the projects settings.py file.
from django.conf.urls import url
Create a virtual environment INSTALLED_APPS = (
--snip-- from . import views
$ python m venv ll_env 'django.contrib.staticfiles',
Activate the environment (Linux and OS X) urlpatterns = [
# My apps url(r'^$', views.index, name='index'),
$ source ll_env/bin/activate 'learning_logs', ]
)
Activate the environment (Windows) Writing a simple view
Migrating the database A view takes information from a request and sends data to the
> ll_env\Scripts\activate browser, often through a template. View functions are stored in an
The database needs to be modified to store the kind of data that
the model represents. apps views.py file. This simple view function doesnt pull in any
Install Django to the active environment data, but it uses the template index.html to render the home page.
(ll_env)$ pip install Django $ python manage.py makemigrations learning_logs
$ python manage.py migrate from django.shortcuts import render

Creating a superuser def index(request):

A superuser is a user account that has access to all aspects of the """The home page for Learning Log."""
To start a project well create a new project, create a project.
database, and start a development server. return render(request,
$ python manage.py createsuperuser 'learning_logs/index.html')
Create a new project
Registering a model
$ django-admin.py startproject learning_log . You can register your models with Djangos admin site, which
makes it easier to work with the data in your project. To do this,
Create a database modify the apps admin.py file. View the admin site at The documentation for Django is available at
$ python manage.py migrate http://localhost:8000/admin/. http://docs.djangoproject.com/. The Django documentation
is thorough and user-friendly, so check it out!
View the project from django.contrib import admin
After issuing this command, you can view the project at
http://localhost:8000/. from learning_logs.models import Topic

$ python manage.py runserver admin.site.register(Topic) Covers Python 3 and Python 2

Create a new app
A Django project is made up of one or more apps.
$ python manage.py startapp learning_logs
 A new model can use an existing model. The ForeignKey
Writing a simple template attribute establishes a connection between instances of the Using data in a template
A template sets up the structure for a page. Its a mix of html and The data in the view functions context dictionary is available
two related models. Make sure to migrate the database
template code, which is like Python but not as powerful. Make a within the template. This data is accessed using template
folder called templates inside the project folder. Inside the after adding a new model to your app. variables, which are indicated by doubled curly braces.
templates folder make another folder with the same name as the The vertical line after a template variable indicates a filter. In this
app. This is where the template files should be saved.
Defining a model with a foreign key
case a filter called date formats date objects, and the filter
class Entry(models.Model): linebreaks renders paragraphs properly on a web page.
<p>Learning Log</p>
"""Learning log entries for a topic.""" {% extends 'learning_logs/base.html' %}
topic = models.ForeignKey(Topic)
<p>Learning Log helps you keep track of your
text = models.TextField() {% block content %}
learning, for any topic you're learning
date_added = models.DateTimeField(
about.</p>
auto_now_add=True) <p>Topic: {{ topic }}</p>
def __str__(self): <p>Entries:</p>
Many elements of a web page are repeated on every page return self.text[:50] + "..." <ul>
in the site, or every page in a section of the site. By writing {% for entry in entries %}
one parent template for the site, and one for each section, <li>
you can easily modify the look and feel of your entire site. <p>
Most pages in a project need to present data thats specific
The parent template to the current user. {{ entry.date_added|date:'M d, Y H:i' }}
The parent template defines the elements common to a set of </p>
pages, and defines blocks that will be filled by individual pages. URL parameters <p>
A URL often needs to accept a parameter telling it which data to {{ entry.text|linebreaks }}
<p> access from the database. The second URL pattern shown here </p>
<a href="{% url 'learning_logs:index' %}"> looks for the ID of a specific topic and stores it in the parameter </li>
Learning Log topic_id.
{% empty %}
</a> urlpatterns = [ <li>There are no entries yet.</li>
</p> url(r'^$', views.index, name='index'), {% endfor %}
url(r'^topics/(?P<topic_id>\d+)/$', </ul>
{% block content %}{% endblock content %} views.topic, name='topic'),
The child template ] {% endblock content %}
The child template uses the {% extends %} template tag to pull in
the structure of the parent template. It then defines the content for
Using data in a view
The view uses a parameter from the URL to pull the correct data
any blocks defined in the parent template.
from the database. In this example the view is sending a context
{% extends 'learning_logs/base.html' %} dictionary to the template, containing data that should be displayed You can explore the data in your project from the command
on the page. line. This is helpful for developing queries and testing code
{% block content %} def topic(request, topic_id): snippets.
<p> """Show a topic and all its entries.""" Start a shell session
Learning Log helps you keep track topic = Topics.objects.get(id=topic_id)
of your learning, for any topic you're entries = topic.entry_set.order_by( $ python manage.py shell
learning about. '-date_added')
</p> Access data from the project
context = {
{% endblock content %} 'topic': topic, >>> from learning_logs.models import Topic
'entries': entries, >>> Topic.objects.all()
} [<Topic: Chess>, <Topic: Rock Climbing>]
return render(request, >>> topic = Topic.objects.get(id=1)
'learning_logs/topic.html', context) >>> topic.text
'Chess'

Python code is usually indented by four spaces. In

templates youll often see two spaces used for indentation, If you make a change to your project and the change
doesnt seem to have any effect, try restarting the server: More cheat sheets available at
because elements tend to be nested more deeply in
templates. $ python manage.py runserver
 Defining the URLs Showing the current login status
Users will need to be able to log in, log out, and register. Make a You can modify the base.html template to show whether the user is
new urls.py file in the users app folder. The login view is a default currently logged in, and to provide a link to the login and logout
view provided by Django. pages. Django makes a user object available to every template,
and this template takes advantage of this object.
from django.conf.urls import url The user.is_authenticated tag allows you to serve specific
from django.contrib.auth.views import login content to users depending on whether they have logged in or not.
The {{ user.username }} property allows you to greet users
from . import views who have logged in. Users who havent logged in see links to
register or log in.
urlpatterns = [ <p>
url(r'^login/$', login, <a href="{% url 'learning_logs:index' %}">
Most web applications need to let users create {'template_name': 'users/login.html'}, Learning Log
accounts. This lets users create and work with their name='login'), </a>
own data. Some of this data may be private, and url(r'^logout/$', views.logout_view, {% if user.is_authenticated %}
name='logout'), Hello, {{ user.username }}.
some may be public. Djangos forms allow users to
url(r'^register/$', views.register, <a href="{% url 'users:logout' %}">
enter and modify their data. name='register'), log out
] </a>
The login template {% else %}
User accounts are handled by a dedicated app called <a href="{% url 'users:register' %}">
users. Users need to be able to register, log in, and log The login view is provided by default, but you need to provide your
own login template. The template shown here displays a simple register
out. Django automates much of this work for you. login form, and provides basic error messages. Make a templates </a> -
Making a users app folder in the users folder, and then make a users folder in the <a href="{% url 'users:login' %}">
templates folder. Save this file as login.html. log in
After making the app, be sure to add 'users' to INSTALLED_APPS
The tag {% csrf_token %} helps prevent a common type of </a>
in the projects settings.py file.
attack with forms. The {{ form.as_p }} element displays the
{% endif %}
$ python manage.py startapp users default login form in paragraph format. The <input> element
named next redirects the user to the home page after a successful </p>
Including URLS for the users app login.
Add a line to the projects urls.py file so the users apps URLs are {% block content %}{% endblock content %}
included in the project. {% extends "learning_logs/base.html" %}
The logout view
urlpatterns = [ {% block content %} The logout_view() function uses Djangos logout() function
url(r'^admin/', include(admin.site.urls)), {% if form.errors %} and then redirects the user back to the home page. Since there is
url(r'^users/', include('users.urls', no logout page, there is no logout template. Make sure to write this
<p>
namespace='users')), code in the views.py file thats stored in the users app folder.
Your username and password didn't match.
url(r'', include('learning_logs.urls', Please try again. from django.http import HttpResponseRedirect
namespace='learning_logs')), </p> from django.core.urlresolvers import reverse
] {% endif %} from django.contrib.auth import logout

<form method="post" def logout_view(request):

action="{% url 'users:login' %}"> """Log the user out."""
{% csrf token %} logout(request)
There are a number of ways to create forms and work with {{ form.as_p }} return HttpResponseRedirect(
them. You can use Djangos defaults, or completely <button name="submit">log in</button> reverse('learning_logs:index'))
customize your forms. For a simple way to let users enter
data based on your models, use a ModelForm. This creates <input type="hidden" name="next"
a form that allows users to enter data that will populate the value="{% url 'learning_logs:index' %}"/>
fields on a model. </form>
The register view on the back of this sheet shows a simple Covers Python 3 and Python 2
approach to form processing. If the view doesnt receive {% endblock content %}
data from a form, it responds with a blank form. If it
receives POST data from a form, it validates the data and
then saves it to the database.
The register view The register template Restricting access to logged-in users
The register view needs to display a blank registration form when The register template displays the registration form in paragraph Some pages are only relevant to registered users. The views for
the page is first requested, and then process completed formats. these pages can be protected by the @login_required decorator.
registration forms. A successful registration logs the user in and Any view with this decorator will automatically redirect non-logged
redirects to the home page. {% extends 'learning_logs/base.html' %} in users to an appropriate page. Heres an example views.py file.
from django.contrib.auth import login {% block content %} from django.contrib.auth.decorators import /
from django.contrib.auth import authenticate login_required
from django.contrib.auth.forms import \ <form method='post' --snip--
UserCreationForm action="{% url 'users:register' %}">
@login_required
def register(request): {% csrf_token %} def topic(request, topic_id):
"""Register a new user.""" {{ form.as_p }} """Show a topic and all its entries."""
if request.method != 'POST':
# Show blank registration form. Setting the redirect URL
<button name='submit'>register</button> The @login_required decorator sends unauthorized users to the
form = UserCreationForm() <input type='hidden' name='next' login page. Add the following line to your projects settings.py file
else: value="{% url 'learning_logs:index' %}"/> so Django will know how to find your login page.
# Process completed form.
form = UserCreationForm( </form> LOGIN_URL = '/users/login/'
data=request.POST)
Preventing inadvertent access
{% endblock content %} Some pages serve data based on a parameter in the URL. You
if form.is_valid(): can check that the current user owns the requested data, and
new_user = form.save() return a 404 error if they dont. Heres an example view.
# Log in, redirect to home page.
pw = request.POST['password1'] Users will have data that belongs to them. Any model that should from django.http import Http404
authenticated_user = authenticate( be connected directly to a user needs a field connecting instances
username=new_user.username, of the model to a specific user. --snip--
password=pw def topic(request, topic_id):
Making a topic belong to a user """Show a topic and all its entries."""
) Only the highest-level data in a hierarchy needs to be directly
login(request, authenticated_user) connected to a user. To do this import the User model, and add it topic = Topics.objects.get(id=topic_id)
return HttpResponseRedirect( as a foreign key on the data model. if topic.owner != request.user:
reverse('learning_logs:index')) After modifying the model youll need to migrate the database. raise Http404
Youll need to choose a user ID to connect each existing instance --snip--
to.
context = {'form': form}
return render(request, from django.db import models
'users/register.html', context) from django.contrib.auth.models import User
If you provide some initial data, Django generates a form
class Topic(models.Model): with the users existing data. Users can then modify and
"""A topic the user is learning about.""" save their data.
The django-bootstrap3 app allows you to use the Bootstrap text = models.CharField(max_length=200)
library to make your project look visually appealing. The Creating a form with initial data
date_added = models.DateTimeField(
app provides tags that you can use in your templates to The instance parameter allows you to specify initial data for a form.
auto_now_add=True)
style individual elements on a page. Learn more at owner = models.ForeignKey(User) form = EntryForm(instance=entry)
http://django-bootstrap3.readthedocs.io/.
def __str__(self): Modifying data before saving
The argument commit=False allows you to make changes before
return self.text writing data to the database.
Heroku lets you push your project to a live server, making it Querying data for the current user new_topic = form.save(commit=False)
available to anyone with an internet connection. Heroku In a view, the request object has a user attribute. You can use this new_topic.owner = request.user
offers a free service level, which lets you learn the attribute to query for the users data. The filter() function then
new_topic.save()
deployment process without any commitment. Youll need pulls the data that belongs to the current user.
to install a set of heroku tools, and use git to track the state topics = Topic.objects.filter(
of your project. See http://devcenter.heroku.com/, and click
More cheat sheets available at
owner=request.user)
on the Python link.