Só começo este post dizendo que o título é mentira. Mas já que você chegou aqui, não custa nada conhecer mais sobre esse framework massa demais chamado Django, certo?.

O que é?

Django é um framework web (dãa) que possui como melhor qualidade a comunidade e os ótimos artigos. A curva de aprendizado não é tão simples assim e os conceitos um pouco díficeis, mesmo para quem vem de outros frameworks web, contudo os ótimos artigos e a ótima documentação permitem que qualquer pessoa com pouquíssima experiência em Python comece a criar coisas em Django se dedicar o tempo necessário para aprender.

Arquitetura

Uma aplicação Django é dividida em apps. E apps são somente pacotes para serem utilizados dentro de aplicações Django. A principal característica de um bom app é sua reusabilidade mas isso não significa que apps devem ser pequenos mas sim, modulares, de forma que eles possam ser removidos(ou substítuidos) sem que haja tantas implicações no projeto.

Tudo isso é gerenciado por um app principal que possui um arquivo chamado settings.py, basicamente  é dele que vem todas as configurações iniciais da sua aplicação Django, é importante compreender quase todos os parâmetros colocados dentro deste settings.py se você estiver sério em construir um app django de qualidade.

Principais Componentes

Existem dois componentes principais em Django: Views e Models. 

Onde as Views são responsáveis por gerenciar o acesso aos Dados e como as respostas às URLs irão acontecer e definidas no arquivo views.py. E os Models por definir a comunicação com o DB e definidos no arquivo models.py.

Exemplo de Views:

class CreateCategory(LoginRequiredMixin, views.StaffuserRequiredMixin, LogMixin, CreateView):
    log_component = 'category'
    log_action = 'create'
    log_resource = 'category'
    log_context = {}

    login_url = reverse_lazy("users:login")
    redirect_field_name = 'next'
    
    form_class = CategoryForm
    template_name = 'categories/create.html'
    success_url = reverse_lazy('categories:index')

    def get_initial(self):
        initial = super(CreateCategory, self).get_initial()

        if self.kwargs.get('slug'):
            category = get_object_or_404(Category, slug = self.kwargs['slug'])
            initial = initial.copy()

            initial['description'] = category.description
            initial['name'] = category.name
            initial['visible'] = category.visible
            initial['coordinators'] = category.coordinators.all()

            self.log_action = 'replicate'

            self.log_context['replicated_category_id'] = category.id
            self.log_context['replicated_category_name'] = category.name
            self.log_context['replicated_category_slug'] = category.slug

        return initial

    def get_context_data(self, **kwargs):
        context = super(CreateCategory, self).get_context_data(**kwargs)
        context['users_count'] = User.objects.all().count()
        context['switch'] = True

        if self.kwargs.get('slug'):
            context['title'] = _('Replicate Category')
        else:
            context['title'] = _('Create Category')

        if 'categories' in self.request.META.get('HTTP_REFERER'):
            context['template_extends'] = 'categories/list.html'
            context['settings_menu_active'] = "settings_menu_active"
        else:
            context['template_extends'] = 'subjects/list.html'
            context['subjects_menu_active'] = 'subjects_menu_active';

        return context

    def form_valid(self, form):
        self.object = form.save()
        
        self.log_context['category_id'] = self.object.id
        self.log_context['category_name'] = self.object.name
        self.log_context['category_slug'] = self.object.slug

        super(CreateCategory, self).createLog(self.request.user, self.log_component, self.log_action, self.log_resource, self.log_context)

        return super(CreateCategory, self).form_valid(form)

    def get_success_url(self):
    
        objeto = self.object.name
        messages.success(self.request, _('Category "%s" register successfully!')%(objeto))
        return reverse_lazy('categories:index')

Exemplo de Models:

from django.db import models
from autoslug.fields import AutoSlugField
from django.utils.translation import ugettext_lazy as _
from users.models import User

class Category(models.Model):
	"""Represents a Course """

	name = models.CharField(_("Name"), max_length = 100, blank = False, null = False, unique = True)
	slug = AutoSlugField(_("Slug"), populate_from = 'name', unique = True)
	description = models.CharField(_("description"), max_length = 300,blank = True, null = True)
	visible = models.BooleanField(_("visible"), default = True)
	coordinators = models.ManyToManyField(User, related_name = "coordinators", blank = True)
	create_date = models.DateTimeField(_('Creation Date'), auto_now_add = True)
	modified_date = models.DateTimeField(_('Modified Date'), auto_now_add = True)

	REQUIRED_FIELDS = ['name',]
	class Meta:
		verbose_name = _('Category')
		verbose_name_plural = _('Categories')

	def __str__(self):
		return self.name

Provavelmente surgiu a dúvida na sua cabeça: de onde o Django acerta quais Views utilizar?

Todos os apps em Django possuem um arquivo chamado urls.py, nele, Django utiliza de regex para criar uma conexão entre um caminho (ex: http://www.teste.com/users/1 ) no browser e uma determinada View, com isso, você não precisa se preocupar muito sobre o que acontece por debaixo dos panos (como a aplicação lê o caminho, transforma em View e como responde ao Browser) e sim sobre o que a sua View vai retornar como resposta.

Exemplo de urls.py:

from django.conf.urls import url
from . import views

urlpatterns = [
	url(r'^$', views.IndexView.as_view(), name='index'),
	url(r'^create/$', views.CreateCategory.as_view(), name='create'),
	url(r'^delete/(?P<slug>[\w_-]+)/$', views.DeleteCategory.as_view(), name='delete'),
	url(r'^replicate/(?P<slug>[\w_-]+)/$', views.CreateCategory.as_view(), name='replicate'),
	url(r'^update/(?P<slug>[\w_-]+)/$', views.UpdateCategory.as_view(), name='update'),
	url(r'^view_log/(?P<category>[\w_-]+)/$', views.category_view_log, name = 'view_log')
]

Os modelos dentro de cada app, por sua vez, são definidos por classes que herdam (geralmente) da classe models.Model padrão do Django, que possuem vários tipos de campos prontos onde o Django framework cuida para o desenvolvedor de como o DB vai ser construido através destes modelos, um conceito importante para entender de frameworks como Django são as migrations, que irei explorar em outros posts.

Então galera, é isso, seguem uns links que podem ajudar à aqueles que procuram se aprofundar mais (e questionar se eu falei alguma besteira por aqui):

(Documentação) https://docs.djangoproject.com/en/1.11/

(Views) https://docs.djangoproject.com/en/1.11/topics/http/views/

(Apps reusáveis) https://docs.djangoproject.com/en/1.11/intro/reusable-apps/