The Ultimate Django Cheatsheet: Because Even Ninjas Need a Little Help Sometimes

January 26, 2023 (2y ago)

Are you a Django ninja who's feeling a little rusty on the details? Or a newbie just trying to navigate the complex world of web development? Well, we've got you covered with the ultimate Django cheatsheet!

First up, let's start with some basic commands. Want to create a new project? Just type django-admin startproject projectname into the command line. Want to start the development server? python manage.py runserver is your new best friend.

But what about when things get a little more complex? Fear not, because we've got you covered with some handy tips and tricks.

  • Want to create a new app within your project? python manage.py startapp appname is all you need.
  • Need to create a new database table? Use python manage.py makemigrations appname to create the initial migration, and then python manage.py migrate to actually apply the changes.
  • Want to add a new field to an existing table? Use python manage.py makemigrations appname again, and then python manage.py migrate as before.
  • Need to create a new superuser? python manage.py createsuperuser will prompt you for a username, email, and password.

And those are just the basics! With the ultimate Django cheatsheet by your side, you'll be able to tackle even the most complex projects with ease. So don't be afraid to get your hands dirty and dive into the world of web development. Because with Django, the possibilities are endless.

So, don't be afraid to use this cheatsheet like a pro and remember, even the most experienced Ninjas needs a little help sometimes.

Defining Django Models

Here's an example of a Django model for a Ninja class in the style of the popular anime/manga series Naruto:

from django.db import models
 
class Ninja(models.Model):
    name = models.CharField(max_length=255)
    village = models.CharField(max_length=255)
    jutsu = models.TextField()
    chakra = models.IntegerField()
    registered_date = models.DateTimeField(auto_now_add=True)
    sharingan = models.BooleanField(default=False)
    team = models.CharField(max_length=255, blank=True, null=True)
    picture = models.ImageField(upload_to='ninja_images', blank=True, null=True)
 
    def __str__(self):
        return self.name

This model defines a Ninja class that inherits from models.Model. It has several fields: name, village, jutsu, chakra, registered_date, sharingan, team, and picture.

The name and village fields are both CharFields, with a maximum length of 255 characters. The jutsu field is a TextField, which can store longer pieces of text, and chakra is an IntegerField representing the amount of chakra a ninja has.

The registered_date field is a DateTimeField with auto_now_add=True this means that it will automatically be set to the current date and time when a new Ninja is created.

The sharingan field is a BooleanField which can be used to represent whether the ninja has the Sharingan or not, with a default value of False.

The team field is a CharField with a maximum length of 255 characters, and is optional(blank=True, null=True) since not all ninjas are part of a team.

Finally, the picture field is an ImageField that will handle the upload of an image of the ninja and store it in the 'ninja_images' directory.

Defining views

Here's an example of a views.py file for a Django application in the style of the popular anime/manga series Naruto:

from django.shortcuts import render
from django.http import HttpResponse
from .models import Ninja
 
def index(request):
    all_ninjas = Ninja.objects.all()
    context = {'all_ninjas': all_ninjas}
    return render(request, 'ninjas/index.html', context)
 
def ninja_detail(request, ninja_id):
    ninja = Ninja.objects.get(pk=ninja_id)
    context = {'ninja': ninja}
    return render(request, 'ninjas/ninja_detail.html', context)
 
def team(request, team_name):
    team_members = Ninja.objects.filter(team__iexact=team_name)
    context = {'team_members': team_members, 'team_name': team_name}
    return render(request, 'ninjas/team.html', context)
 
def search(request):
    query = request.GET.get('q')
    search_results = Ninja.objects.filter(name__icontains=query)
    context = {'search_results': search_results, 'query': query}
    return render(request, 'ninjas/search.html', context)

This views.py file contains several functions that handle different pages of the application:

  • The index function retrieves all the Ninja objects from the database using the Ninja.objects.all() method and stores them in the context dictionary. Then it renders the index.html template and passes the context to it.
  • The ninja_detail function retrieves a specific Ninja object from the database using the Ninja.objects.get(pk=ninja_id) method and stores it in the context dictionary. Then it renders the ninja_detail.html template and passes the context to it.
  • The team function retrieves all the Ninja objects that belong to a specific team using the Ninja.objects.filter(team__iexact=team_name) method and stores them in the context dictionary. Then it renders the team.html template and passes the context to it.
  • The search function retrieves all the Ninja objects whose name contains a specific query using the Ninja.objects.filter(name__icontains=query) method and stores them in the context dictionary. Then it renders the search.html template and passes the context to it.

It's important to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Connecting Views to URL Endpoints

Here’s an example of how to connect the views we have defined to their endpoints

from django.urls import path
from . import views
 
urlpatterns = [
    path('', views.index, name='index'),
    path('ninja/<int:ninja_id>/', views.ninja_detail, name='ninja_detail'),
    path('team/<str:team_name>/', views.team, name='team'),
    path('search/', views.search, name='search'),
]

This urls.py file maps URLs to the corresponding views in the views.py file:

  • The empty string '' maps to the index view.
  • The string 'ninja/<int:ninja_id>/' maps to the ninja_detail view, and includes a variable ninja_id that is passed to the view as an argument.
  • The string 'team/<str:team_name>/' maps to the team view, and includes a variable team_name that is passed to the view as an argument.
  • The string 'search/' maps to the search view.

You can also notice that each path has a name, this names can be used in the template to generate URLs. Also, it's important to include this urls.py file in the main urls.py file of your project with the include function.

Rendering HTML Responses for above views

index.html

<h1>Welcome to the Ninja Database</h1>
<ul>
{% for ninja in all_ninjas %}
    <li><a href="{% url 'ninja_detail' ninja.id %}">{{ ninja.name }}</a> from {{ ninja.village }}</li>
{% endfor %}
</ul>

This template displays a heading and an unordered list of all the ninjas in the database. Each list item contains a link to the ninja_detail view for that specific ninja, using the {% url %} template tag to generate the URL and passing the ninja.id as the ninja_id argument.

ninja_detail.html

<h1>{{ ninja.name }}</h1>
<p>Village: {{ ninja.village }}</p>
<p>Jutsu: {{ ninja.jutsu }}</p>
<p>Chakra: {{ ninja.chakra }}</p>
<p>Has Sharingan: {% if ninja.sharingan %}yes{% else %}no{% endif %}</p>
<p>Team: {% if ninja.team %}{{ ninja.team }}{% else %}none{% endif %}</p>
{% if ninja.picture %}
    <img src="{{ ninja.picture.url }}" alt="{{ ninja.name }}">
{% endif %}

This template displays the details of a single ninja, including name, village, jutsu, chakra, Sharingan,etc.

Function Based Views

from django.shortcuts import render, get_object_or_404
from .models import Ninja
 
def index(request):
    all_ninjas = Ninja.objects.all()
    context = {'all_ninjas': all_ninjas}
    return render(request, 'ninjas/index.html', context)
 
def ninja_detail(request, ninja_id):
    ninja = get_object_or_404(Ninja, pk=ninja_id)
    context = {'ninja': ninja}
    return render(request, 'ninjas/ninja_detail.html', context)
 
def team(request, team_name):
    team_members = Ninja.objects.filter(team__iexact=team_name)
    context = {'team_members': team_members, 'team_name': team_name}
    return render(request, 'ninjas/team.html', context)
 
def search(request):
    query = request.GET.get('q')
    search_results = Ninja.objects.filter(name__icontains=query)
    context = {'search_results': search_results, 'query': query}
    return render(request, 'ninjas/search.html', context)

This is similar to the previous example, the main difference is the use of get_object_or_404 function in ninja_detail view to handle cases when the ninja_id passed in the URL is not found.

It's important to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Class Based Views

from django.shortcuts import render
from django.views.generic import ListView, DetailView
from .models import Ninja
 
class NinjaListView(ListView):
    model = Ninja
    template_name = 'ninjas/index.html'
    context_object_name = 'all_ninjas'
 
class NinjaDetailView(DetailView):
    model = Ninja
    template_name = 'ninjas/ninja_detail.html'
    context_object_name = 'ninja'
 
class TeamView(ListView):
    template_name = 'ninjas/team.html'
    context_object_name = 'team_members'
 
    def get_queryset(self):
        return Ninja.objects.filter(team__iexact=self.kwargs['team_name'])
 
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['team_name'] = self.kwargs['team_name']
        return context
 
class SearchView(ListView):
    template_name = 'ninjas/search.html'
    context_object_name = 'search_results'
 
    def get_queryset(self):
        query = self.request.GET.get('q')
        return Ninja.objects.filter(name__icontains=query)
 
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['query'] = self.request.GET.get('q')
        return context

This is similar to the function-based views example, but it uses Django's built-in class-based views to handle the common logic of displaying lists and details of objects. The ListView and DetailView classes are generic views that handle fetching and paginating the objects from the database, and rendering the template.

It's important to notice that TeamView and SearchView are subclasses of ListView and they implement the methods get_queryset and get_context_data to handle the specific logic of displaying a team members and search results. It's important also to notice that this is just an example, and you may need to adapt this views to your specific use case and also to add the URL routing for these views.

Forms

from django import forms
from .models import Ninja
 
class NinjaForm(forms.ModelForm):
    class Meta:
        model = Ninja
        fields = ['name', 'village', 'jutsu', 'chakra', 'sharingan', 'team', 'picture']
 
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['jutsu'].widget.attrs.update({'class': 'jutsu-selector'})
        self.fields['team'].widget.attrs.update({'class': 'team-selector'})
        self.fields['picture'].widget.attrs.update({'class': 'picture-input'})
 
class SearchForm(forms.Form):
    query = forms.CharField(label='Search for a ninja', max_length=100)
    team = forms.ChoiceField(choices=[('', 'All teams'), ('Team 7', 'Team 7'), ('Team 8', 'Team 8'), ('Team 10', 'Team 10'), ('Akatsuki', 'Akatsuki')], required=False)

This is an example of how to create a form to manage the data of a Ninja model. The NinjaForm class is a ModelForm that is created using the Ninja model and the fields specified in the fields attribute.

The __init__ method is overriden to add classes to the widgets of the form fields, for example jutsu-selector to jutsu field, team-selector to team field and picture-input to picture field.

The SearchForm class is a regular Form class, it's created using the CharField and ChoiceField form fields. The query field is used to search for a ninja by name, and the team field is used to filter the search results by team.

The choices attribute of the ChoiceField is used to specify the available teams to filter by, and the required=False attribute is used to make the field optional, so the user can search for ninjas without filtering by team.

Django Apps

python manage.py startapp uchiha-clan

This command will create a new directory called "uchiha-clan" in your project's root directory. This directory will contain the necessary files and directories for a Django app, such as models.py, views.py, urls.py, migrations/ and admin.py.

You can then use the files in this directory to define your models, views, URLs, and other components of your app related to uchiha clan.

It's important to notice that after creating the app, you should make sure to add it to the INSTALLED_APPS list in the settings.py file of your project so that Django knows about the new app and can use it.

Adding an app to settings.py

Database Configuration

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Timezone Configuration

TIME_ZONE = 'UTC'

Application Configuration

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app1',
    'app2',
    'app3',
]

Middleware Configuration

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Allowed Hosts

The ALLOWED_HOSTS setting is used to specify a list of hostnames that this Django site can serve. This is a security measure to prevent an attacker from poisoning caches and password reset emails with links to malicious hosts by submitting requests with a fake HTTP Host header, which is possible even under many seemingly-safe webserver configurations.

ALLOWED_HOSTS = ['example.com', 'www.example.com']

Static files

In production, you will also want to serve your static files using a separate web server, such as Apache or Nginx, rather than using the built-in Django development server. You'll need to configure your web server to serve the files in the STATIC_ROOT directory.

Here's an exa

mple of how you might set STATIC_ROOT and STATIC_URL in your settings.py file:

STATIC_ROOT = os.path.join(BASE_DIR, 'static')
STATIC_URL = '/static/'

In addition, you might want to configure your web server to serve media files as well.

Conclusion

In conclusion, mastering the art of Django can be a daunting task, but with our ninja-inspired cheatsheet, you'll be slicing and dicing your way to the top of the leaderboard in no time! Whether you're a beginner or an expert, you'll be able to unleash the full power of the Sharingan with our easy-to-use guide. Remember, just like the Uchiha clan, you too can have the power to control the nine-tailed fox (or in this case, your code) with the right training. So what are you waiting for? Grab your kunai and get coding like a true ninja!

Rick SanchezFavicon by Icons8

Design Template by Lee Robinson