Creation of the site on Python: Flask and Django

How to Create a Website with Python: A Complete Guide to Flask and Django

Building your own website has become accessible to all aspiring programmers thanks to the Python programming language. Modern web development frameworks allow you to create both simple single-page sites and complex web portals with an administrative panel, database, and user session system.

In this guide, we will thoroughly examine the process of creating a website with Python from scratch. We will explore two major frameworks, Flask and Django, identify their advantages and disadvantages, and provide step-by-step instructions for their installation and configuration.

Advantages of Python for Web Development

Python has gained popularity among web developers due to numerous advantages:

Simple syntax – the code is readable and understandable even for beginners
High level of abstraction – allows you to focus on the application logic rather than low-level details
Extensive community – millions of developers share ready-made solutions and libraries
Modern technologies – built-in support for REST API, WebSockets, machine learning
Powerful frameworks – Flask and Django cover the needs of most web projects
Rich ecosystem – thousands of ready-made packages for solving any tasks

Developing a Website with Flask

Introduction to Flask

Flask is a lightweight microframework for building web applications in Python. It is ideal for small projects, rapid prototyping, and educational purposes. The main philosophy of Flask is to provide a minimal set of tools, leaving the developer free to choose additional components.

Flask Installation and Configuration

Flask is installed via the pip package manager:

pip install flask

For project isolation, it is recommended to use a virtual environment:

python -m venv myflaskapp
source myflaskapp/bin/activate  # Linux/Mac
myflaskapp\Scripts\activate     # Windows
pip install flask

Creating a Simple Web Application

Create a file app.py with a basic application:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Welcome to your first Flask website!"

@app.route('/about')
def about():
    return "About Us page"

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

Run the server with the command:

python app.py

Open your browser and go to http://127.0.0.1:5000 - your first website is ready to go.

Working with Templates in Flask

To create full-fledged HTML pages, use the Jinja2 template system. Create a templates folder and an index.html file:

<!DOCTYPE html>
<html>
<head>
    <title>My Flask Website</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

Update app.py to work with templates:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html', 
                         title='Homepage',
                         message='Welcome to our website!')

Implementing Sessions in Flask

Flask Session allows you to store user data between requests. This is especially important for authorization and content personalization:

from flask import Flask, session, redirect, url_for, request, render_template_string

app = Flask(__name__)
app.secret_key = 'your_secret_key_here'

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        
        # Simple check (use hashing in a real project)
        if username == 'admin' and password == 'secret':
            session['username'] = username
            session['logged_in'] = True
            return redirect(url_for('profile'))
        else:
            return "Incorrect login details"
    
    return '''
    <form method="post">
        <p>Username: <input type="text" name="username" required></p>
        <p>Password: <input type="password" name="password" required></p>
        <p><input type="submit" value="Login"></p>
    </form>
    '''

@app.route('/profile')
def profile():
    if 'logged_in' in session and session['logged_in']:
        return f"Welcome, {session['username']}! <a href='/logout'>Logout</a>"
    return redirect(url_for('login'))

@app.route('/logout')
def logout():
    session.clear()
    return redirect(url_for('login'))

Working with a Database in Flask

Use SQLAlchemy to connect to the database:

pip install flask-sqlalchemy

Example of working with a database:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

with app.app_context():
    db.create_all()

Creating a Web Application with Django

Introduction to Django

Django is a full-featured framework for developing complex web applications. Unlike Flask, Django follows the "batteries included" principle and provides ready-made solutions for most web development tasks.

The main components of Django:

ORM (Object-Relational Mapping) for working with databases
Routing system for handling URL addresses
Administrative panel for content management
Template system for creating HTML pages
Middleware for processing requests and responses
Authorization and user management system

Django Installation and Initial Setup

Install Django via pip:

pip install django

Creating a Django Project

Create a new project with the command:

django-admin startproject mysite
cd mysite

Structure of the created project:

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Run the development server:

python manage.py runserver

Open your browser and go to http://127.0.0.1:8000. You will see the Django welcome page.

Creating a Django Application

Django projects consist of applications. Create a blog application:

python manage.py startapp blog

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',  # Add your application
]

Creating Views and Routes

Create a view in the blog/views.py file:

from django.http import HttpResponse
from django.shortcuts import render

def home(request):
    return HttpResponse("Welcome to our Django blog!")

def about(request):
    context = {
        'title': 'About Us',
        'content': 'Information about our website'
    }
    return render(request, 'blog/about.html', context)

Create a blog/urls.py file:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='blog-home'),
    path('about/', views.about, name='blog-about'),
]

Update the main routing file mysite/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),
]

Working with Models and Databases

Create models in the blog/models.py file:

from django.db import models
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    date_posted = models.DateTimeField(auto_now_add=True)
    author = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['-date_posted']

Create and apply migrations:

python manage.py makemigrations
python manage.py migrate

Configuring the Administrative Panel

from django.contrib import admin
from .models import Post

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ['title', 'author', 'date_posted']
    list_filter = ['date_posted', 'author']
    search_fields = ['title', 'content']

Create a superuser:

python manage.py createsuperuser

Deploying Django to Production

Production Setup

Update settings.py for production:

DEBUG = False
ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com']

# Static files
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

# Production database
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'your_db_name',
        'USER': 'your_db_user',
        'PASSWORD': 'your_db_password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Running with Gunicorn

Install and configure Gunicorn:

pip install gunicorn
gunicorn mysite.wsgi:application --bind 0.0.0.0:8000

gunicorn mysite.wsgi:application \
    --workers 3 \
    --bind 0.0.0.0:8000 \
    --timeout 120 \
    --max-requests 1000

Additionally, configure Nginx as a reverse proxy and for processing static files.

Comparative Analysis of Flask and Django

Detailed Comparison of Frameworks

Criterion	Flask	Django
Learning Curve	Low, quick start	Medium, takes time
Architectural Flexibility	Maximum freedom	Strict but proven structure
Project Size	Ideal for small to medium	Optimal for medium to large
Administrative Panel	Requires creation from scratch	Ready out of the box
ORM	Needs to be connected separately	Built-in Django ORM
Authorization System	Requires setup	Full system out of the box
Performance	Higher on low loads	Optimized for large projects
Community	Active	Very large and active

Recommendations for Choosing

Choose Flask when:

Creating a simple website or API
You need maximum flexibility in architecture
Developing a prototype or MVP
Learning web development in Python
Integration with a microservice architecture is required

Choose Django when:

Developing a complex web application
You need rapid development with ready-made components
Creating an online store or CMS
An administrative panel is required
Working in a team of developers

Frequently Asked Questions

Framework Compatibility

Can Flask and Django be used in the same project?

Technically, this is possible through a microservice architecture, where each service uses its own framework. However, within one application, this does not make practical sense. It is better to choose one framework for specific project tasks.

Flask Session Mechanism

What is Flask Session?

Flask Session is a mechanism for saving user data between HTTP requests. Sessions allow you to store information about the user's state, such as authorization data, interface settings, or the contents of a shopping cart. Session data is encrypted and stored in browser cookies or on the server.

Deploying Django to Production

How to properly run a Django server for real use?

For production, use professional WSGI servers:

pip install gunicorn nginx

gunicorn mysite.wsgi:application --workers 3 --bind 0.0.0.0:8000

gunicorn mysite.wsgi:application \
    --workers 3 \
    --bind 0.0.0.0:8000 \
    --timeout 120 \
    --max-requests 1000

Additionally, configure Nginx as a reverse proxy and for processing static files.

Choosing a Framework for E-commerce

What is better to choose for creating an online store?

Django is recommended for the following reasons:

Ready-made administrative panel for managing products
Built-in authorization and user system
ORM for complex database queries
Ready-made packages for e-commerce (Django Oscar, Saleor)
Scalability for large product catalogs
Permission system for different user roles

Creating REST API

Can I create a REST API using Flask and Django?

Yes, both frameworks are great for creating APIs:

pip install flask flask-restful

pip install djangorestframework

Django REST Framework provides more ready-made tools: serialization, pagination, filtering, token-based authorization.

Framework Performance

Which framework works faster?

Flask demonstrates better performance at startup and at low loads due to its minimalism. Django shows advantages when scaling due to built-in optimization tools: caching, lazy loading, connection pooling, and optimized SQL queries.

Conclusion

Creating a website with Python has become accessible thanks to the powerful Flask and Django frameworks. Flask provides simplicity and flexibility for a quick start and small projects, while Django provides a complete set of tools for developing large-scale and reliable web applications.

When choosing a framework, be guided by the specifics of your project, the experience of the team, and long-term goals. Remember that both tools have active communities and extensive documentation, which facilitates the learning and development process.

Start with simple projects, experiment with different features, and gradually complicate your web applications. Creating websites with Python opens up wide opportunities for implementing the most daring ideas in web development.