Comprehensive Guide to Web Development with Python: From Flask to Django

Technical writer

Python

13.02.2024

Reading time: 14 min

Immense popularity has been gained by Python in web development because of its versatility and simplicity. This comprehensive guide will walk through the basics, covering Flask and Django frameworks, working with templates and views, database integration, handling forms, adding user authentication, and developing RESTful APIs. Following manual addresses towards steps on how to use Python for web development.

Flask and Django

Python has two frameworks for web development: Flask and Django. Both of these can be deployed on our app platform. Flask is a simple framework and is capable of making simple web apps as compared to Django which is more complex than Flask and also has more built-in features. Despite the differences, both frameworks are used by some of the most visited websites today. These sites include Netflix, Spotify, Uber, Zomato etc.

Getting started with Flask

Follow these steps to set up a basic Flask application:

Install Flask using the following command:

pip install flask

Create a new Python file, e.g., app.py, and add the following code:

from flask import Flask
app = Flask(__name__) 
@app.route('/')
def hello_world():
return 'Hello, Flask!'

Run the application with:

flask run app.py

Afterwards, the terminal will output a link similar to http://127.0.0.1:5000/. By clicking this page, the app will appear in the user’s default browser with the instructions of “hello world” as was stated in the code.

Transitioning to Django

Django is a more robust framework that follows the Model-View-Controller (MVC) pattern. Install Django and create a project:

Install Django using:

pip install django

Create a new Django project:

django-admin startproject myproject

Run the development server:

python manage.py runserver

Afterwards, the terminal will output a link similar to http://127.0.0.1:8000/. By clicking this page, the app will appear in the user’s default browser.

Working with templates and views

In both Flask and Django, templates and views play a crucial role in rendering dynamic content.

Create an HTML template in Flask

Create a templates folder in Flask project folder.
Add an HTML file, e.g., index.html, with your template.

Code for HTML is as follows:

<!-- templates/index.html --> 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ page_title }}</title>
</head>
<body>
    <header>
        <h1>{{ heading }}</h1>
    </header>
    <section>
        <p>{{ content }}</p>
    </section>
    <footer>
        <p>Your Flask App</p>
    </footer>
</body>
</html>

This HTML template includes placeholders (enclosed in double curly braces {{...}}) that Flask will replace with actual values during rendering.

Use templates in Flask

In the Flask application, the render_template function is used to render the HTML template with dynamic content. Below is an example:

# Example: Using templates in Flask

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    # Provide dynamic content to the template
    template_data = {
        'page_title': 'Home Page',
        'heading': 'Welcome to Flask!',
        'content': 'This is a sample Flask web application.',
    }
    return render_template('index.html', **template_data)

if __name__ == '__main__':
    app.run(debug=True)

In this example, the render_template function is used to render the index.html template with dynamic content provided by the template_data dictionary.

By incorporating this Flask-specific code, the HTML template is seamlessly integrated into the Flask application, allowing for the dynamic rendering of content.

Create an HTML template in Django

In order to create a view in Django, follow the stated guidelines:

Define a view function in the views.py file.

from django.shortcuts import render
 
def index(request):
    context = {
        'page_title': 'Django Home',
        'heading': 'Welcome to Django!',
        'content': 'This is your Django app homepage.',
    }
    return render(request, 'your_app/index.html', context)

In this example, the index view function prepares a context dictionary with values for the placeholders in the HTML template. It then renders the index.html template using the render function.

Map the view to a URL in urls.py.

Now, open the urls.py file in your app folder. Create a URL pattern that maps to the index view function.

from django.urls import path
from .views import index
 
urlpatterns = [
    path('', index, name='index'),
]

Database integration

Database integration is essential for dynamic web applications.

Connecting databases in Flask

Add the following to your Flask app:

from flask_sqlalchemy import SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)

Define models for your database.

Once Flask-SQLAlchemy is integrated, proceed to define models for your database. Databases are tables which are represented by models. In the Python programming language, these are Python classes. Below is a simplified example:

from datetime import datetime
from flask_sqlalchemy import SQLAlchemy
 
db = SQLAlchemy()
 
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    date_joined = db.Column(db.DateTime, default=datetime.utcnow)
 
    def __repr__(self):
        return f"User('{self.username}', '{self.email}')"

Connecting databases in Django

In Django, configuring databases is handled through the settings.py file. Follow these steps to set up a PostgreSQL database or another supported database:

Modify settings.py.

Open the settings.py file within your Django project folder. Locate the DATABASES configuration section, and modify the ENGINE, NAME, USER, and PASSWORD parameters accordingly.

# Example: Configuring a PostgreSQL database in Django
 
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'your_database_name',
        'USER': 'your_database_user',
        'PASSWORD': 'your_database_password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Replace the placeholder values with your specific database details.

Run migrations:

After modifying the database configuration, run the following commands to apply the changes and create necessary tables:

python manage.py makemigrations

python manage.py migrate

These commands create database tables based on the defined models.

With these configurations, your Flask application is now connected to a SQLite database, and your Django application is set up with the specified database, allowing seamless integration for dynamic web functionalities.

Handling forms and user input

Forms play a pivotal role in facilitating user interaction on web applications. This section delineates the process of creating a simple form in Flask using the WTForms library and constructing a form in Django through Django forms, integrated seamlessly with a view.

Form handling in Flask

Forms are vital for user interaction. Create a simple form in Flask:

Use the WTForms library:

pip install Flask-WTF

Define a form in your Flask app.

Below is a basic example illustrating how to create a registration form using Flask-WTF:

# Example: Defining a simple form in Flask using WTForms 

from flask import Flask, render_template
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
 
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'
 
class RegistrationForm(FlaskForm):
    username = StringField('Username')
    password = PasswordField('Password')
    submit = SubmitField('Register')
 
@app.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()
    if form.validate_on_submit():
        # Process the form data (e.g., save to database)
        return 'Registration successful!'
 
    return render_template('register.html', form=form)

In this example, the RegistrationForm class is created, defining fields for username, password, and a submit button. The form is then integrated into a route (/register), and upon submission, the data can be processed as needed.

Handling a form in Django

In Django, form handling is seamlessly integrated using Django forms. Follow these steps to create and integrate a form within your Django app.

Define a form using Django's form framework. Below is an example of a simple registration form in Django:

from django import forms

class RegistrationForm(forms.Form):
    username = forms.CharField(label='Username', max_length=100)
    password = forms.CharField(label='Password', widget=forms.PasswordInput)

Integrate the form with your view.

Integrate the form into your Django view. Modify your existing view or create a new one to handle the form submission:

from django.shortcuts import render
from .forms import RegistrationForm

def register(request):
    form = RegistrationForm(request.POST or None)

    if form.is_valid():
        # Process the form data (e.g., save to database)
        return render(request, 'registration_success.html')

    return render(request, 'register.html', {'form': form})

This example assumes the existence of HTML templates (register.html and registration_success.html) for rendering the form and success messages.

With these implementations, both Flask and Django applications can seamlessly handle forms, enabling effective user input and interaction.

Adding user authentication

User authentication is crucial for most web applications.

Secure user authentication in Flask

Implement authentication in Flask:

Use Flask-Login for session management:

pip install flask-login

Implement login and logout routes.

After installing Flask-Login, integrate it into your Flask application. Below is a simplified example illustrating the implementation of login and logout routes:

from flask import Flask, render_template,redirect,url_for
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'

# Sample User class (replace with your user model)
class User(UserMixin):
    def __init__(self, user_id):
        self.id = user_id

login_manager = LoginManager(app)
login_manager.login_view = 'login'

@login_manager.user_loader
def load_user(user_id):
    return User(user_id)

@app.route('/login')
def login():
    # Implement your login logic here
    user = User(user_id=1)
    login_user(user)
    return 'Login successful!'

@app.route('/logout')
@login_required
def logout():
    logout_user()
    return 'Logout successful!'

Customize the user authentication logic within the login route as per your application's requirements.

Secure user authentication in Django

In Django, use the built-in authentication system.

Include django.contrib.auth in the INSTALLED_APPS list.

Open the settings.py file within your Django project folder. Locate the INSTALLED_APPS list and include django.contrib.auth:

INSTALLED_APPS = [
    # ... other apps ...
    'django.contrib.auth',
    # ... other apps ...
]

Run migrations to create necessary tables.

Execute the following commands to apply migrations and create the necessary tables for user authentication:

python manage.py makemigrations
python manage.py migrate

These commands create tables such as auth_user needed for storing user authentication information.

With these implementations, both Flask and Django applications are equipped with secure user authentication mechanisms. Flask utilizes Flask-Login for session management, while Django leverages its built-in authentication system, ensuring the confidentiality and integrity of user credentials.

RESTful API development

RESTful APIs play a pivotal role in facilitating communication between different components of a web application

API development in Flask

Define a Flask app and API endpoint.

In your Flask application, define a route that serves as your API endpoint. Below is an example:

# Example: Creating a simple API endpoint in Flask

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/hello', methods=['GET'])
def hello_world():
    return jsonify({'message': 'Hello, World!'})

This example creates a Flask app and a route (/api/hello) that returns a JSON response with a simple greeting.

Run the Flask app.

Start your Flask development server to test the API endpoint:

flask run

Visit http://127.0.0.1:5000/api/hello in your browser or a tool like Postman to interact with the API.

RESTful API in Django

Ensure Django and Django REST Framework are installed. Use the following commands:

pip install django djangorestframework

Create a Django Project and App, if not done already. Follow the standard Django project creation steps.

In the Django app, define API views and serializers. Below is an example:

# In views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

class HelloWorld(APIView):
    def get(self, request):
        return Response({'message': 'Hello, World!'}, status=status.HTTP_200_OK)

# In serializers.py
from rest_framework import serializers

class HelloWorldSerializer(serializers.Serializer):
    message = serializers.CharField(max_length=100)

Configure URLs in your app's urls.py file:

# In urls.py
from django.urls import path
from .views import HelloWorld

urlpatterns = [
    path('hello/', HelloWorld.as_view(), name='hello-world'),
]

This sets up a Django project with an API endpoint at http://127.0.0.1:8000/hello/.

Run migrations and start Django development server. Write the following in your terminal:

python manage.py migrate
python manage.py runserver

Visit http://127.0.0.1:8000/hello/ to interact with the Django API endpoint.

With these implementations, you've created a simple API endpoint in both Flask and Django, enabling seamless communication within your web applications.

Middleware and extensions

Enhancing Flask with Flask-Migrate and custom middleware

Install Flask-Migrate.

Begin by installing Flask-Migrate, a Flask extension for handling database migrations:

pip install Flask-Migrate

Initialize and perform database migrations.

Initialize the migration environment and apply migrations to your database:

flask db init
flask db migrate
flask db upgrade

These commands set up the necessary migration files and apply them to the database.

Implement middleware in Flask.

In Flask, middleware allows you to define functions that run before and after request handling. As an example, let's create a simple logging middleware:

# Example: Simple logging middleware in Flask

from flask import Flask, request

app = Flask(__name__)

@app.before_request
def log_request_info():
    app.logger.info(f'Received request: {request.method} {request.url}')

@app.after_request
def log_response_info(response):
    app.logger.info(f'Sent response: {response.status_code}')
    return response

if __name__ == '__main__':
    app.run(debug=True)

This middleware logs information about incoming requests and outgoing responses.

Django with middleware

Configure middleware in Django.

In Django, middleware classes are employed to process requests and responses globally. Add middleware classes in the MIDDLEWARE setting within your Django project's settings.py. As an illustration, let's add Django's built-in CommonMiddleware:

# Example: Configuring middleware in Django settings.py

MIDDLEWARE = [
    # ... other middleware classes
    'django.middleware.common.CommonMiddleware',
    # ... other middleware classes
]

CommonMiddleware adds security and performance-related headers to your responses.

Create custom middleware in Django:

You can create custom middleware by defining a class with methods like process_request or process_response. Use the following example Python code:

# Example: Creating a custom logging middleware in Django

# In myapp/middleware.py
class LoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        # Code to be executed for each response afte
        # the view is called.
        return response

Add custom middleware to MIDDLEWARE:

# Example: Adding custom middleware to Django settings.py

MIDDLEWARE = [
    # ... other middleware classes
    'myapp.middleware.LoggingMiddleware',
    # ... other middleware classes
]

Ensure you replace myapp.middleware.LoggingMiddleware with the actual path to your middleware.

Conclusion

In conclusion, this comprehensive guide has equipped you with the fundamental knowledge of web development using Python. Whether you choose Flask for its simplicity or Django for its robust features, the skills learned here form a solid foundation for creating dynamic and powerful web applications. Now, go ahead and unleash the full potential of Python for web development.

Python

13.02.2024

Reading time: 14 min

Similar

Python

Comprehensive Guide to Web Development with Python: From Flask to Django

Flask and Django

Getting started with Flask

Transitioning to Django

Working with templates and views

Create an HTML template in Flask

Use templates in Flask

Create an HTML template in Django

Database integration

Connecting databases in Flask

Connecting databases in Django

Handling forms and user input

Form handling in Flask

Handling a form in Django

Adding user authentication

Secure user authentication in Flask

Secure user authentication in Django

RESTful API development

API development in Flask

RESTful API in Django

Middleware and extensions

Enhancing Flask with Flask-Migrate and custom middleware

Django with middleware

Conclusion

Similar

The Walrus Operator in Python

Python String Functions

Deploying Python Applications with Gunicorn

Do you have questions, comments, or concerns?

Do you have questions,
comments, or concerns?