The Django project is one of the most popular web application frameworks in the Python world. Django implements something like an MVC pattern, but with some subtle differences.

The Django (core) component architecture is illustrated in the following diagram:

Django core component architecture

The core components of the Django framework are as follows:

One of the most powerful components of the Django framework is its automatic admin system, which reads metadata from the Django models, and generates quick, model-centric admin views, where administrators of the system can view and edit data models via simple HTML forms.

For illustration, the following is an example of a Django model that describes a term that is added to a website as a glossary term (a glossary is a list or index of words that describes the meaning of words related to a specific subject, text, or dialect):

from django.db import models

class GlossaryTerm(models.Model):
    """ Model for describing a glossary word (term) """
    
    term = models.CharField(max_length=1024)
    meaning = models.CharField(max_length=1024)
    meaning_html = models.CharField('Meaning with HTML markup',
                    max_length=4096, null=True, blank=True)
    example = models.CharField(max_length=4096, null=True, blank=True)

    # can be a ManyToManyField?
    domains = models.CharField(max_length=128, null=True, blank=True)

    notes = models.CharField(max_length=2048, null=True, blank=True)
    url = models.CharField('URL', max_length=2048, null=True, blank=True)
    name = models.ForeignKey('GlossarySource', verbose_name='Source', blank=True)

    def __unicode__(self):
        return self.term

    class Meta:
        unique_together = ('term', 'meaning', 'url')

This is combined with an admin system that registers a model for an automated admin view:

from django.contrib import admin

admin.site.register(GlossaryTerm)
admin.site.register(GlossarySource)

The following is a screenshot of the automated admin view (HTML form) for adding a glossary term via the Django admin interface:

Django automated admin view (HTML form) for adding a glossary term

A quick observation tells you how the Django admin is able to generate the correct field type for the different data fields in the model, and generate a form for adding the data. This is a powerful pattern present in Django that allows one to generate automated admin views for adding/editing models with almost no coding effort.

Let's now look at another popular Python web application framework, namely Flask.

Flask is a micro web framework that uses a minimalistic philosophy for building web applications. Flask relies on just two libraries: the Werkzeug (http://werkzeug.pocoo.org/) WSGI toolkit and the Jinja2 templating framework.

Flask comes with simple URL routing via decorators. The micro word in Flask indicates that the core of the framework is small. Support for databases, forms, and others is provided by multiple extensions that the Python community has built around Flask.

The core Flask can thus be thought of as an MTV framework minus the M (View Template), since the core does not implement support for models.

Here is an approximate schematic diagram of the Flask component architecture:

Schematic diagram of Flask components

A simple Flask application using templates looks something like this:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
    data = 'some data'
    return render_template('index.html', **locals())

We can find a few components of the MVC pattern right here: