Flask против Django: как создать веб-сайт на Python с нуля

Для кого эта статья:

• Начинающие и опытные разработчики, интересующиеся созданием веб-приложений на Python
• Специалисты, рассматривающие выбор между фреймворками Flask и Django для своих проектов

• Учебные заведения и курсы, обучающие студентов веб-разработке на Python

  Запустить собственный веб-проект на Python — задача, с которой сталкивается каждый разработчик, решивший выйти за рамки консольных скриптов. Но выбор между легковесным Flask и мощным Django часто ставит в тупик даже опытных программистов. Я потратил сотни часов на разработку и поддержку проектов на обоих фреймворках и готов поделиться пошаговым руководством, которое превратит абстрактные знания в работающий сайт. От настройки окружения до развёртывания — каждый этап разложен по полочкам с примерами кода и практическими советами. 🚀

Хотите за 9 месяцев овладеть навыками создания профессиональных веб-приложений на Python? Программа Обучение Python-разработке от Skypro позволит вам не только освоить Flask и Django с нуля, но и научиться интегрировать их с современными технологиями. Пока другие будут разбираться в документации, вы уже создадите полноценные проекты под руководством практикующих разработчиков и получите первое предложение о работе!

Flask или Django: выбор Python-фреймворка для вашего сайта

Выбор фреймворка – первый и, пожалуй, самый важный шаг в начале вашего веб-проекта. Flask и Django представляют собой два противоположных подхода к разработке: минималистичный и полнофункциональный соответственно.

Flask – это микрофреймворк, который даёт вам только базовые инструменты и полную свободу в архитектуре приложения. Django же предлагает готовую экосистему с административной панелью, ORM для работы с базами данных и множеством встроенных решений.

Михаил Петров, технический директор В прошлом году мы столкнулись с необходимостью быстро запустить MVP для стартапа в сфере доставки. Времени было мало, а команда состояла всего из двух бэкенд-разработчиков. Несмотря на мой многолетний опыт работы с Django, я принял решение использовать Flask.

Когда я объявил об этом команде, многие удивились. "Почему не Django с его готовой админкой и ORM?" — спрашивали они. Но я видел, что наш проект имел чёткую и узкую спецификацию: API для мобильного приложения без сложной бизнес-логики.

Flask позволил нам запуститься за 3 недели вместо запланированных 2 месяцев. Мы не тратили время на настройку компонентов Django, которые не собирались использовать. А когда проект вырос и потребовал административную панель, мы просто подключили Flask-Admin.

Спустя год наш сервис обрабатывает более 10 000 заказов ежедневно, а бэкенд по-прежнему работает на Flask с минимальными доработками. Этот опыт научил меня главному: выбор фреймворка должен определяться не его популярностью, а соответствием конкретным задачам проекта.

Идеальный сценарий для Flask:

• Небольшие проекты с ограниченным функционалом
• API и микросервисная архитектура
• Проекты, требующие нестандартной архитектуры
• Обучение веб-разработке на Python с нуля
• Прототипирование и MVP с минимальными затратами времени

Django лучше подойдёт, если вы разрабатываете:

• Крупные веб-приложения с множеством функций
• Проекты с сложными административными интерфейсами
• Сайты, требующие встроенной системы аутентификации и авторизации
• Приложения с обширной работой с базами данных
• Проекты с жёсткими сроками, где важна скорость разработки

Важно понимать, что нет "правильного" выбора – есть только более подходящий инструмент для конкретной задачи. 🛠️

Настройка рабочего окружения для разработки на Flask и Django

Перед погружением в код, необходимо настроить рабочее окружение. Этот этап критически важен, поскольку правильная настройка окружения избавит вас от множества проблем в будущем.

Для начала вам потребуется установить Python. Рекомендую использовать версию не ниже 3.8, так как она обеспечивает поддержку новейших возможностей языка и совместима с последними версиями обоих фреймворков.

Шаг 1: Установка Python и виртуального окружения

Независимо от выбранного фреймворка, создание изолированного окружения – обязательный шаг:

# Установка virtualenv (если еще не установлен)
pip install virtualenv

# Создание виртуального окружения
# Для Flask
virtualenv flask_env
# Для Django
virtualenv django_env

# Активация окружения
# В Windows
flask_env\Scripts\activate # или django_env\Scripts\activate
# В Linux/Mac
source flask_env/bin/activate # или source django_env/bin/activate

Шаг 2: Установка фреймворков

После активации виртуального окружения устанавливаем нужный фреймворк:

# Для Flask
pip install Flask

# Для Django
pip install Django

Для более продвинутой разработки рекомендую установить дополнительные инструменты:

Шаг 3: Настройка редактора кода

Выбор IDE или текстового редактора значительно влияет на эффективность разработки. Для Python-разработки рекомендую:

• VS Code с расширениями Python, Pylance и соответствующими расширениями для Flask/Django
• PyCharm (особенно версия Professional для Django-разработки)
• Sublime Text с пакетами для Python (для легковесных проектов)

Шаг 4: Настройка системы контроля версий

# Инициализация Git-репозитория
git init

# Создание файла .gitignore
echo "venv/
*.pyc
__pycache__/
instance/
.env
.DS_Store" > .gitignore

Правильно настроенное окружение сэкономит вам часы отладки и позволит сконцентрироваться на разработке функционала. 💻

Создание базового веб-сайта на Flask: структура и основной код

Flask привлекает своей простотой и минимализмом. Давайте создадим базовое приложение с несколькими страницами, которое демонстрирует основные возможности фреймворка.

Структура проекта

Рекомендую следующую организацию файлов для небольшого Flask-приложения:

flask_project/
│
├── app/
│ ├── __init__.py
│ ├── routes.py
│ ├── models.py
│ └── templates/
│ ├── base.html
│ ├── index.html
│ └── about.html
│
├── static/
│ ├── css/
│ │ └── style.css
│ └── js/
│ └── main.js
│
├── config.py
├── run.py
└── requirements.txt

Шаг 1: Создание приложения

Начнем с базовой настройки. Сначала создадим файл app/__init__.py:

from flask import Flask

app = Flask(__name__)
app.config.from_object('config')

from app import routes

Затем конфигурационный файл config.py:

import os

SECRET_KEY = os.environ.get('SECRET_KEY') or 'ваш-секретный-ключ'
DEBUG = True

И точку входа run.py:

from app import app

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

Шаг 2: Определение маршрутов

В файле app/routes.py определим маршруты для нашего приложения:

from flask import render_template
from app import app

@app.route('/')
def index():
return render_template('index.html', title='Главная')

@app.route('/about')
def about():
return render_template('about.html', title='О нас')

Шаг 3: Создание шаблонов

Создадим базовый шаблон templates/base.html:

<!DOCTYPE html>
<html>
<head>
<title>{{ title }}</title>
<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
<nav>
<a href="{{ url_for('index') }}">Главная</a>
<a href="{{ url_for('about') }}">О нас</a>
</nav>
<div class="content">
{% block content %}{% endblock %}
</div>
<script src="{{ url_for('static', filename='js/main.js') }}"></script>
</body>
</html>

Затем создадим templates/index.html:

{% extends "base.html" %}

{% block content %}
<h1>Добро пожаловать на наш сайт!</h1>
<p>Это главная страница Flask-приложения.</p>
{% endblock %}

И templates/about.html:

{% extends "base.html" %}

{% block content %}
<h1>О нас</h1>
<p>Мы команда разработчиков, создающих потрясающие веб-приложения на Flask.</p>
{% endblock %}

Шаг 4: Добавление работы с базой данных

Для полноценного приложения добавим работу с базой данных, используя SQLAlchemy. Сначала установим необходимые пакеты:

pip install flask-sqlalchemy flask-migrate

Модифицируем app/__init__.py:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config.from_object('config')

db = SQLAlchemy(app)
migrate = Migrate(app, db)

from app import routes, models

В файле app/models.py определим модели:

from app import db
from datetime import datetime

class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)

def __repr__(self):
return f'Post("{self.title}", "{self.created_at}")'

Шаг 5: Создание форм и добавление постов

Установим Flask-WTF для работы с формами:

pip install flask-wtf

Создадим файл app/forms.py:

from flask_wtf import FlaskForm
from wtforms import StringField, TextAreaField, SubmitField
from wtforms.validators import DataRequired

class PostForm(FlaskForm):
title = StringField('Заголовок', validators=[DataRequired()])
content = TextAreaField('Содержание', validators=[DataRequired()])
submit = SubmitField('Опубликовать')

Добавим новый маршрут в app/routes.py:

from flask import render_template, redirect, url_for
from app import app, db
from app.models import Post
from app.forms import PostForm

@app.route('/post/new', methods=['GET', 'POST'])
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data, content=form.content.data)
db.session.add(post)
db.session.commit()
return redirect(url_for('index'))
return render_template('create_post.html', title='Новый пост', form=form)

И создадим шаблон templates/create_post.html:

{% extends "base.html" %}

{% block content %}
<h1>Создать новый пост</h1>
<form method="POST" action="">
{{ form.hidden_tag() }}
<div>
{{ form.title.label }}
{{ form.title }}
</div>
<div>
{{ form.content.label }}
{{ form.content }}
</div>
<div>
{{ form.submit }}
</div>
</form>
{% endblock %}

Обновим файл config.py:

import os

SECRET_KEY = os.environ.get('SECRET_KEY') or 'ваш-секретный-ключ'
DEBUG = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///site.db'
SQLALCHEMY_TRACK_MODIFICATIONS = False

Таким образом, мы получили базовое, но функциональное веб-приложение на Flask с возможностью создания и просмотра постов. 📝

Пошаговая разработка веб-приложения на Django: от идеи до запуска

Django предоставляет более структурированный подход к разработке веб-приложений с богатым набором встроенных инструментов. Создадим блог с базовой функциональностью.

Анна Соколова, Python-разработчик Когда мне поручили разработать корпоративный портал с системой документооборота, сроки были очень сжатыми – всего 6 недель. Имея за плечами опыт работы с Flask, я всё же выбрала Django, хотя некоторые коллеги считали этот фреймворк "слишком тяжёлым" для быстрого старта.

Первую неделю я потратила исключительно на изучение Django и настройку проекта. Это был настоящий стресс: вместо написания кода я погрузилась в документацию и отчаянно пыталась понять MVT-архитектуру фреймворка. В какой-то момент я даже пожалела о своём выборе и думала переключиться на Flask.

Но всё изменилось на второй неделе. Освоив базовые концепции, я была поражена скоростью разработки. Аутентификация, административная панель, система миграций – всё работало "из коробки". За один день я реализовала функционал, который на Flask занял бы неделю.

К финальному дедлайну портал был не просто готов – он имел расширенный функционал, которого даже не было в изначальных требованиях. Django действительно оказался идеальным выбором для этого проекта, несмотря на более крутую кривую обучения.

Шаг 1: Создание проекта

После установки Django создаем новый проект и приложение:

# Создание проекта
django-admin startproject blog_project

# Переходим в директорию проекта
cd blog_project

# Создание приложения
python manage.py startapp blog

Структура проекта будет выглядеть примерно так:

blog_project/
│
├── blog_project/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ ├── asgi.py
│ └── wsgi.py
│
├── blog/
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── tests.py
│ ├── views.py
│ ├── urls.py # создаем сами
│ └── migrations/
│
└── manage.py

Шаг 2: Настройка проекта

Регистрируем приложение в blog_project/settings.py:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'blog', # наше приложение
]

# Настройка базы данных (SQLite по умолчанию)
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}

# Указываем директории для статических файлов
STATIC_URL = '/static/'
STATICFILES_DIRS = [
BASE_DIR / "static",
]

# Настройка для медиафайлов
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

Шаг 3: Создание модели

Определим модель для нашего блога в blog/models.py:

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

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

def get_absolute_url(self):
return reverse('post-detail', kwargs={'pk': self.pk})

Применим миграции:

python manage.py makemigrations
python manage.py migrate

Шаг 4: Регистрация в админке

Регистрируем модель в административной панели (blog/admin.py):

from django.contrib import admin
from .models import Post

admin.site.register(Post)

Шаг 5: Создание представлений (views)

В файле blog/views.py создадим представления для отображения постов:

from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from .models import Post

class PostListView(ListView):
model = Post
template_name = 'blog/home.html'
context_object_name = 'posts'
ordering = ['-date_posted']
paginate_by = 5

class PostDetailView(DetailView):
model = Post

class PostCreateView(LoginRequiredMixin, CreateView):
model = Post
fields = ['title', 'content']

def form_valid(self, form):
form.instance.author = self.request.user
return super().form_valid(form)

class PostUpdateView(LoginRequiredMixin, UserPassesTestMixin, UpdateView):
model = Post
fields = ['title', 'content']

def form_valid(self, form):
form.instance.author = self.request.user
return super().form_valid(form)

def test_func(self):
post = self.get_object()
return self.request.user == post.author

class PostDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
model = Post
success_url = '/'

def test_func(self):
post = self.get_object()
return self.request.user == post.author

Шаг 6: Настройка URL-маршрутов

Создадим файл blog/urls.py:

from django.urls import path
from .views import PostListView, PostDetailView, PostCreateView, PostUpdateView, PostDeleteView

urlpatterns = [
path('', PostListView.as_view(), name='blog-home'),
path('post/<int:pk>/', PostDetailView.as_view(), name='post-detail'),
path('post/new/', PostCreateView.as_view(), name='post-create'),
path('post/<int:pk>/update/', PostUpdateView.as_view(), name='post-update'),
path('post/<int:pk>/delete/', PostDeleteView.as_view(), name='post-delete'),
]

Обновим главный файл URL-маршрутов (blog_project/urls.py):

from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static

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

if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Шаг 7: Создание шаблонов

Создадим базовый шаблон blog/templates/blog/base.html:

<!DOCTYPE html>
<html>
<head>
<title>Django Blog</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
<a class="navbar-brand" href="{% url 'blog-home' %}">Django Blog</a>
<div class="navbar-nav">
<a class="nav-item nav-link" href="{% url 'blog-home' %}">Главная</a>
<a class="nav-item nav-link" href="{% url 'post-create' %}">Новый пост</a>
</div>
</nav>

<main class="container mt-4">
{% block content %}{% endblock %}
</main>

<script src="https://code.jquery.com/jquery-3.5.1.slim.min.js"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
</body>
</html>

Шаблон для домашней страницы blog/templates/blog/home.html:

{% extends "blog/base.html" %}

{% block content %}
{% for post in posts %}
<article class="card mb-4">
<div class="card-header">
<h2><a href="{% url 'post-detail' post.id %}">{{ post.title }}</a></h2>
<small>Автор: {{ post.author }} | {{ post.date_posted|date:"F d, Y" }}</small>
</div>
<div class="card-body">
<p>{{ post.content|truncatewords:50 }}</p>
</div>
</article>
{% endfor %}

{% if is_paginated %}
<nav>
<ul class="pagination">
{% if page_obj.has_previous %}
<li class="page-item"><a class="page-link" href="?page=1">Первая</a></li>
<li class="page-item"><a class="page-link" href="?page={{ page_obj.previous_page_number }}">Предыдущая</a></li>
{% endif %}

{% for num in page_obj.paginator.page_range %}
{% if num == page_obj.number %}
<li class="page-item active"><a class="page-link" href="?page={{ num }}">{{ num }}</a></li>
{% elif num > page_obj.number|add:'-3' and num < page_obj.number|add:'3' %}
<li class="page-item"><a class="page-link" href="?page={{ num }}">{{ num }}</a></li>
{% endif %}
{% endfor %}

{% if page_obj.has_next %}
<li class="page-item"><a class="page-link" href="?page={{ page_obj.next_page_number }}">Следующая</a></li>
<li class="page-item"><a class="page-link" href="?page={{ page_obj.paginator.num_pages }}">Последняя</a></li>
{% endif %}
</ul>
</nav>
{% endif %}
{% endblock %}

Шаблон для отображения поста blog/templates/blog/post_detail.html:

{% extends "blog/base.html" %}

{% block content %}
<article class="card">
<div class="card-header">
<h2>{{ object.title }}</h2>
<small>Автор: {{ object.author }} | {{ object.date_posted|date:"F d, Y" }}</small>
{% if object.author == user %}
<div class="mt-2">
<a class="btn btn-sm btn-outline-secondary" href="{% url 'post-update' object.id %}">Редактировать</a>
<a class="btn btn-sm btn-outline-danger" href="{% url 'post-delete' object.id %}">Удалить</a>
</div>
{% endif %}
</div>
<div class="card-body">
<p>{{ object.content }}</p>
</div>
</article>
{% endblock %}

Шаг 8: Запуск и тестирование

Создадим суперпользователя для доступа к админ-панели:

python manage.py createsuperuser

Запустим сервер для разработки:

python manage.py runserver

Теперь у нас есть полноценный блог на Django с возможностью создания, редактирования и удаления постов, а также с пагинацией и административной панелью. 🏆

Сравнение Flask и Django: что подойдет для вашего проекта

После изучения обоих фреймворков возникает естественный вопрос: какой из них лучше выбрать для конкретного проекта? Ответ зависит от множества факторов.

Рассмотрим конкретные сценарии:

Выбирайте Flask, если:

• Разрабатываете микросервис или API с ограниченным набором функций
• Создаёте прототип или MVP, который нужно быстро запустить
• Хотите полностью контролировать архитектуру приложения
• Ваш проект имеет нестандартные требования к архитектуре
• Вы начинающий разработчик и хотите понять основы веб-разработки
• Работаете с ограниченными ресурсами (память, процессор)

Выбирайте Django, если:

• Создаёте полноценное веб-приложение с множеством функций
• Важна скорость разработки и соблюдение сроков
• Требуется встроенная система аутентификации и авторизации
• Нужна административная панель "из коробки"
• Работаете в команде, где важна стандартизация кода
• Безопасность приложения является приоритетом
• Проект будет активно расширяться в будущем

Производительность и масштабирование

В чистом сравнении производительности Flask обычно опережает Django из-за своей легковесности. Однако при правильной оптимизации оба фреймворка могут обслуживать миллионы запросов.

Ключевые аспекты масштабирования:

• Flask: Легче оптимизировать конкретные узкие места, но требуется больше ручной работы.
• Django: Предоставляет инструменты для оптимизации (кэширование, ORM-оптимизации), но имеет больше "движущихся частей".

Совет профессионала

Для многих проектов правильным решением может быть гибридный подход:

1. Используйте Django для основного приложения с его богатыми возможностями управления контентом, аутентификацией и административным интерфейсом.
2. Разрабатывайте высоконагруженные API или микросервисы на Flask, которые могут взаимодействовать с основным приложением.

В конечном счёте, выбор фреймворка – это компромисс между скоростью разработки, производительностью и удобством поддержки. Для большинства проектов Django предлагает лучший баланс этих факторов, но если вам нужна предельная гибкость или вы создаёте что-то нестандартное – Flask может оказаться более подходящим выбором. 🧠

Выбор между Flask и Django – это не просто техническое решение, а стратегический шаг, определяющий будущее вашего проекта. Начните с малого, но думайте о перспективе. Flask даст вам свободу экспериментов и тонкой настройки, Django – скорость разработки и встроенную структуру. Но помните: хороший программист может создать отличный продукт на любом из этих фреймворков, ведь главное не инструмент, а понимание задачи и умение её решить.