Django или Flask: что выбрать для веб-разработки на Python

# Устанавливаем Django
pip install django
 
# Создаём проект
django-admin startproject mywebsite
 
# Создаём приложение внутри проекта
cd mywebsite
python manage.py startapp blog
 
# Определяем модель в blog/models.py
from django.db import models
 
class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')
    
    def __str__(self):
        return self.title

# В mywebsite/settings.py добавляем
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    # ...другие стандартные приложения...
    'blog',
]
 
# Затем выполняем миграции
python manage.py makemigrations
python manage.py migrate

# В blog/admin.py
from django.contrib import admin
from .models import Post
 
admin.site.register(Post)

# В blog/views.py
from django.shortcuts import render
from .models import Post
 
def post_list(request):
    posts = Post.objects.order_by('-pub_date')
    return render(request, 'blog/post_list.html', {'posts': posts})

# В blog/urls.py
from django.urls import path
from . import views
 
urlpatterns = [
    path('', views.post_list, name='post_list'),
]
 
# А в mywebsite/urls.py
from django.contrib import admin
from django.urls import path, include
 
urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),
]

# В settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.jinja2.Jinja2',
        'DIRS': [os.path.join(BASE_DIR, 'templates/jinja2')],
        'APP_DIRS': True,
        'OPTIONS': {
            'environment': 'myproject.jinja2.environment',
        },
    },
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                # Другие процессоры контекста
            ],
        },
    },
]

# Пример установки и настройки django-allauth для аутентификации
[H2]через социальные сети[/H2]
 
# Установка через pip
pip install django-allauth
 
# В settings.py
INSTALLED_APPS = [
    # ...
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'allauth.socialaccount.providers.github',
    'allauth.socialaccount.providers.google',
]
 
MIDDLEWARE = [
    # ...
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    # ...
]
 
AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
    'allauth.account.auth_backends.AuthenticationBackend',
]
 
SITE_ID = 1

from django.db import models
 
class Author(models.Model):
    name = models.CharField(max_length=100)
    bio = models.TextField(blank=True)
    
    def __str__(self):
        return self.name
 
class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    publication_date = models.DateField()
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=6, decimal_places=2)
    
    def __str__(self):
        return f"{self.title} by {self.author.name}"

# Создание новой записи
author = Author.objects.create(name="Дж. К. Роулинг")
book = Book(
    title="Гарри Поттер и философский камень", 
    author=author,
    publication_date="1997-06-26",
    pages=332,
    price=19.99
)
book.save()
 
# Поиск и фильтрация
harry_potter_books = Book.objects.filter(title__contains="Гарри Поттер")
expensive_books = Book.objects.filter(price__gt=20.00)
recent_books = Book.objects.filter(publication_date__year=2023)
 
# Сложные запросы с соединениями
rowling_books = Book.objects.filter(author__name="Дж. К. Роулинг")

class Category(models.Model):
    name = models.CharField(max_length=50)
    
    def __str__(self):
        return self.name
 
class Book(models.Model):
    # ... предыдущие поля ...
    categories = models.ManyToManyField(Category)

# Найти все книги в категории "Фэнтези"
fantasy = Category.objects.get(name="Фэнтези")
fantasy_books = fantasy.book_set.all()
 
# Или в обратную сторону
harry_potter = Book.objects.get(title="Гарри Поттер и философский камень")
categories = harry_potter.categories.all()

books = Book.objects.all()
for book in books:
    print(f"{book.title} by {book.author.name}")

# Теперь всего 2 запроса вместо N+1
books = Book.objects.select_related('author').all()
for book in books:
    print(f"{book.title} by {book.author.name}")

from django.db.models import Avg
 
authors = Author.objects.annotate(avg_price=Avg('book__price'))
for author in authors:
    print(f"{author.name}: средняя цена {author.avg_price}")

from django.db import connection
 
with connection.cursor() as cursor:
    cursor.execute("""
        SELECT a.name, COUNT(b.id) as book_count, AVG(b.price) as avg_price
        FROM author a
        JOIN book b ON b.author_id = a.id
        GROUP BY a.name
        HAVING COUNT(b.id) > 5
        ORDER BY avg_price DESC
    """)
    results = cursor.fetchall()

from django.contrib import admin
from .models import Author, Book, Category
 
admin.site.register(Author)
admin.site.register(Book)
admin.site.register(Category)

class BookAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'publication_date', 'price')  # Столбцы в списке
    list_filter = ('author', 'publication_date')  # Фильтры справа
    search_fields = ('title', 'author__name')  # Поля для поиска
    date_hierarchy = 'publication_date'  # Навигация по датам
    ordering = ('-publication_date',)  # Порядок сортировки
 
admin.site.register(Book, BookAdmin)

class BookAdmin(admin.ModelAdmin):
    # ... предыдущие настройки ...
    actions = ['mark_as_bestseller']
 
    def mark_as_bestseller(self, request, queryset):
        queryset.update(is_bestseller=True)
    mark_as_bestseller.short_description = "Пометить как бестселлер"

from flask import Flask
 
app = Flask(__name__)
 
@app.route('/')
def hello_world():
    return 'Привет, мир!'
 
if __name__ == '__main__':
    app.run(debug=True)

# Установка необходимых расширений
pip install flask-sqlalchemy flask-login flask-wtf
 
# Использование в приложении
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, UserMixin
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
 
app = Flask(__name__)
app.config['SECRET_KEY'] = 'супер-секретный-ключ'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
 
# Инициализация расширений
db = SQLAlchemy(app)
login_manager = LoginManager(app)
 
# Определение модели
class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    password = db.Column(db.String(60), nullable=False)
 
# Форма для входа
class LoginForm(FlaskForm):
    username = StringField('Имя пользователя')
    password = PasswordField('Пароль')
    submit = SubmitField('Войти')

from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
 
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
db = SQLAlchemy(app)
 
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)
    date_posted = db.Column(db.DateTime, default=datetime.utcnow)
 
    def __repr__(self):
        return f"Post('{self.title}', '{self.date_posted}')"
 
@app.route('/')
def home():
    posts = Post.query.order_by(Post.date_posted.desc()).all()
    return render_template('home.html', posts=posts)
 
@app.route('/post/<int:post_id>')
def post(post_id):
    post = Post.query.get_or_404(post_id)
    return render_template('post.html', post=post)
 
@app.route('/create', methods=['GET', 'POST'])
def create():
    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']
        new_post = Post(title=title, content=content)
        db.session.add(new_post)
        db.session.commit()
        return redirect(url_for('home'))
    return render_template('create.html')
 
if __name__ == '__main__':
    db.create_all()  # Создаём таблицы при первом запуске
    app.run(debug=True)

from flask import Flask, jsonify, request
app = Flask(__name__)
 
# База данных для примера
books = [
    {"id": 1, "title": "Война и мир", "author": "Лев Толстой"},
    {"id": 2, "title": "1984", "author": "Джордж Оруэлл"}
]
 
@app.route('/api/books', methods=['GET'])
def get_books():
    return jsonify(books)
 
@app.route('/api/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((b for b in books if b["id"] == book_id), None)
    if book is None:
        return jsonify({"error": "Книга не найдена"}), 404
    return jsonify(book)
 
@app.route('/api/books', methods=['POST'])
def add_book():
    if not request.json:
        return jsonify({"error": "Данные не в JSON формате"}), 400
    
    new_book = {
        "id": len(books) + 1,
        "title": request.json.get('title', ''),
        "author": request.json.get('author', '')
    }
    books.append(new_book)
    return jsonify(new_book), 201

import pytest
from app import app
 
@pytest.fixture
def client():
    app.config['TESTING'] = True
    with app.test_client() as client:
        yield client
 
def test_get_books(client):
    response = client.get('/api/books')
    assert response.status_code == 200
    assert len(response.json) == 2

@app.route('/hello')
def hello():
    return "Привет, мир!"

@app.route('/user/<username>')
def show_user_profile(username):
    return f'Пользователь: {username}'
 
@app.route('/post/<int:post_id>')
def show_post(post_id):
    # post_id будет преобразован в целое число
    return f'Пост №{post_id}'

@app.route('/api/resource', methods=['GET'])
def get_resource():
    return jsonify({"resources": [...]})
 
@app.route('/api/resource', methods=['POST'])
def create_resource():
    data = request.json
    # Создание ресурса
    return jsonify({"status": "created"}), 201

from flask import Blueprint, render_template
 
auth_bp = Blueprint('auth', __name__, url_prefix='/auth')
 
@auth_bp.route('/login')
def login():
    return render_template('login.html')
 
@auth_bp.route('/register')
def register():
    return render_template('register.html')
 
# В основном файле приложения:
app.register_blueprint(auth_bp)

from flask import request
 
@app.route('/search')
def search():
    query = request.args.get('q', '')
    return f'Вы искали: {query}'
 
@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return 'Файл не предоставлен'
    
    file = request.files['file']
    # Обработка загруженного файла
    return 'Файл загружен'

@app.before_request
def load_user():
    if 'user_id' in session:
        g.user = User.query.get(session['user_id'])
    else:
        g.user = None
 
@app.after_request
def add_header(response):
    response.headers['X-Frame-Options'] = 'DENY'
    return response

# Пример простого бенчмарка с Flask
from flask import Flask
app = Flask(__name__)
 
@app.route('/api/hello')
def hello():
    return {'message': 'Hello, World!'}
 
# А теперь то же самое в Django
# urls.py
from django.urls import path
from . import views
 
urlpatterns = [
    path('api/hello', views.hello_world),
]
 
# views.py
from django.http import JsonResponse
 
def hello_world(request):
    return JsonResponse({'message': 'Hello, World!'})

# Замеряем использование памяти в простом Flask-приложении
import os
import psutil
from flask import Flask
 
app = Flask(__name__)
 
@app.route('/')
def memory_usage():
    # Получаем процесс Python
    process = psutil.Process(os.getpid())
    # Возвращаем использование памяти в МБ
    memory_use = process.memory_info().rss / 1024 / 1024
    return f"Использование памяти: {memory_use:.2f} МБ"
 
if __name__ == '__main__':
    app.run(debug=False)

# settings.py - оптимизированная конфигурация Django
INSTALLED_APPS = [
    'django.contrib.auth',
    'django.contrib.contenttypes',
    # Убрали неиспользуемые компоненты:
    # 'django.contrib.sessions',
    # 'django.contrib.messages',
    # 'django.contrib.staticfiles',
    # 'django.contrib.admin',
    'myapp',
]

# В шаблонах Django защита от CSRF встроена
<form method="post">
    {% csrf_token %}
    <!-- поля формы -->
    <button type="submit">Отправить</button>
</form>

# Реализация CSRF-защиты во Flask через расширение
from flask_wtf.csrf import CSRFProtect
 
app = Flask(__name__)
app.config['SECRET_KEY'] = 'тайный-ключ'
csrf = CSRFProtect(app)
 
# Теперь нужно добавлять токен в каждую форму
# {{ csrf_token() }} в шаблонах

from flask import Flask, request, jsonify
import jwt
import datetime
 
app = Flask(__name__)
app.config['SECRET_KEY'] = 'ваш-секретный-ключ'
 
@app.route('/auth/token', methods=['POST'])
def create_token():
    username = request.json.get('username', '')
    password = request.json.get('password', '')
    
    # Здесь должна быть проверка учётных данных
    if username == 'test' and password == 'password':
        token = jwt.encode({
            'user': username,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }, app.config['SECRET_KEY'])
        return jsonify({'token': token})
    
    return jsonify({'error': 'Invalid credentials'}), 401
 
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

# Пример взаимодействия различных модулей в Django
# models.py
class Product(models.Model):
    name = models.CharField(max_length=200)
    stock_level = models.IntegerField(default=0)
    low_stock_threshold = models.IntegerField(default=10)
    
    @property
    def needs_reordering(self):
        return self.stock_level <= self.low_stock_threshold
 
class Order(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    status = models.CharField(max_length=20, choices=ORDER_STATUSES)
    
    @property
    def total_value(self):
        return sum(item.price for item in self.items.all())
    
    def process(self):
        # Обновление товарных запасов
        for item in self.items.all():
            item.product.stock_level -= item.quantity
            item.product.save()
        
        # Обновление статуса
        self.status = 'PROCESSED'
        self.save()