PrepBro
← Назад к вопросам

Что такое контекстный процессор (context processor)?

2.0 Middle🔥 111 комментариев
#Django

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI22 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Что такое контекстный процессор (context processor)

Контекстный процессор (context processor) — это механизм в шаблонизаторах (например, Django, Jinja2) и веб-фреймворках для автоматического предоставления данных всем шаблонам приложения. Это функция, которая возвращает словарь переменных, доступных в контексте шаблона.

Основная идея

Вместо того чтобы передавать одни и те же данные в каждый шаблон, контекстный процессор делает эти данные глобально доступными:

# БЕЗ контекстного процессора (повторяющийся код)
from django.shortcuts import render

def home(request):
    context = {
        'user': request.user,
        'site_name': 'MyApp',
        'current_year': 2025
    }
    return render(request, 'home.html', context)

def about(request):
    context = {
        'user': request.user,
        'site_name': 'MyApp',
        'current_year': 2025
    }
    return render(request, 'about.html', context)

def contact(request):
    context = {
        'user': request.user,
        'site_name': 'MyApp',
        'current_year': 2025
    }
    return render(request, 'contact.html', context)

С использованием контекстного процессора

# С контекстным процессором (DRY принцип)
from django.shortcuts import render

def home(request):
    return render(request, 'home.html')

def about(request):
    return render(request, 'about.html')

def contact(request):
    return render(request, 'contact.html')

# Контекстный процессор
def global_context(request):
    return {
        'user': request.user,
        'site_name': 'MyApp',
        'current_year': 2025
    }

Создание контекстного процессора в Django

Шаг 1: Создание функции процессора

# app/context_processors.py

from django.utils import timezone
from django.conf import settings

def site_info(request):
    """Предоставить информацию о сайте"""
    return {
        'site_name': 'My Awesome App',
        'site_version': '1.0.0',
        'current_year': timezone.now().year,
        'support_email': 'support@example.com',
        'is_production': settings.DEBUG is False
    }

def user_info(request):
    """Предоставить информацию о пользователе"""
    user_data = {
        'is_authenticated': request.user.is_authenticated,
    }
    
    if request.user.is_authenticated:
        user_data.update({
            'username': request.user.username,
            'email': request.user.email,
            'full_name': request.user.get_full_name(),
            'is_staff': request.user.is_staff
        })
    
    return user_data

def feature_flags(request):
    """Предоставить флаги функций (feature flags)"""
    return {
        'enable_new_dashboard': True,
        'enable_beta_features': request.user.is_staff,
        'max_upload_size': 10 * 1024 * 1024  # 10MB
    }

Шаг 2: Регистрация процессора в settings.py

# settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                # Наши контекстные процессоры
                'myapp.context_processors.site_info',
                'myapp.context_processors.user_info',
                'myapp.context_processors.feature_flags',
            ],
        },
    },
]

Шаг 3: Использование в шаблоне

<!-- template.html -->
<!DOCTYPE html>
<html>
<head>
    <title>{{ site_name }} - v{{ site_version }}</title>
</head>
<body>
    <header>
        <h1>{{ site_name }}</h1>
        <p>Year: {{ current_year }}</p>
    </header>
    
    <nav>
        {% if is_authenticated %}
            <span>Welcome, {{ full_name }}!</span>
            <a href="/logout">Logout</a>
        {% else %}
            <a href="/login">Login</a>
        {% endif %}
    </nav>
    
    <main>
        {% if enable_new_dashboard %}
            <section>New Dashboard is available!</section>
        {% endif %}
        
        {% if is_staff and enable_beta_features %}
            <section>Beta features unlocked!</section>
        {% endif %}
    </main>
    
    <footer>
        <p>Support: {{ support_email }}</p>
        <p>Environment: {% if is_production %}Production{% else %}Development{% endif %}</p>
    </footer>
</body>
</html>

Встроенные контекстные процессоры Django

Джанго поставляется с несколькими встроенными процессорами:

# django.template.context_processors.debug
# Предоставляет debug, sql_queries для отладки

# django.template.context_processors.request
# Предоставляет request объект

# django.contrib.auth.context_processors.auth
# Предоставляет user, perms

# django.contrib.messages.context_processors.messages
# Предоставляет messages для flash-уведомлений

# django.template.context_processors.media
# Предоставляет MEDIA_URL, MEDIA_ROOT

# django.template.context_processors.static
# Предоставляет STATIC_URL

# django.template.context_processors.csrf
# Предоставляет csrf_token

Практические примеры

1. Метаинформация сайта

# context_processors.py

from django.conf import settings
from datetime import datetime

def site_metadata(request):
    return {
        'site_title': 'My Blog',
        'site_description': 'A blog about Python development',
        'copyright_year': datetime.now().year,
        'social_links': {
            'twitter': 'https://twitter.com/myblog',
            'github': 'https://github.com/myblog',
            'linkedin': 'https://linkedin.com/company/myblog'
        },
        'api_url': settings.API_URL
    }

2. Уведомления и сообщения

# context_processors.py

from django.contrib.messages import get_messages

def notifications(request):
    messages = get_messages(request)
    return {
        'notifications': messages,
        'unread_count': sum(1 for _ in messages if not _.extra_tags),
        'has_errors': any(m.level >= 40 for m in messages)
    }

3. Настройки приложения

# context_processors.py

from django.conf import settings
from django.core.cache import cache

def app_config(request):
    config = cache.get('app_config')
    if not config:
        config = {
            'max_file_size': getattr(settings, 'MAX_FILE_SIZE', 5 * 1024 * 1024),
            'allowed_extensions': getattr(settings, 'ALLOWED_EXTENSIONS', []),
            'pagination_size': getattr(settings, 'PAGINATION_SIZE', 20),
            'debug': settings.DEBUG,
            'timezone': settings.TIME_ZONE
        }
        cache.set('app_config', config, 60 * 60)  # Cache для 1 часа
    
    return config

4. Аналитика и отслеживание

# context_processors.py

from django.conf import settings

def analytics(request):
    return {
        'google_analytics_id': getattr(settings, 'GOOGLE_ANALYTICS_ID', None),
        'sentry_dsn': getattr(settings, 'SENTRY_DSN', None),
        'environment': getattr(settings, 'ENVIRONMENT', 'development')
    }

Контекстные процессоры в других фреймворках

Flask

from flask import Flask
from datetime import datetime

app = Flask(__name__)

@app.context_processor
def inject_global_data():
    """Добавить глобальные данные в контекст шаблона"""
    return {
        'site_name': 'My Flask App',
        'current_year': datetime.now().year,
        'user': get_current_user()
    }

@app.route('/')
def home():
    # site_name, current_year, user автоматически доступны
    return render_template('home.html')

Jinja2 (самостоятельно)

from jinja2 import Environment, FileSystemLoader

def get_global_context():
    return {
        'site_name': 'My App',
        'current_year': 2025
    }

env = Environment(loader=FileSystemLoader('templates'))
template = env.get_template('index.html')

# Передать контекст
output = template.render(**get_global_context())

Лучшие практики

# ✓ ХОРОШО: Разделить логику по файлам
# app/context_processors/user.py
def user_context(request):
    return {'user': request.user}

# app/context_processors/site.py
def site_context(request):
    return {'site_name': 'MyApp'}

# ✗ ПЛОХО: Большой контекстный процессор
def everything_context(request):
    return {
        'user': request.user,
        'site_name': 'MyApp',
        'all': 'the', 
        'things': 'go',
        'here': '!'
    }

# ✓ ХОРОШО: Использовать кэширование
def cached_context(request):
    key = f'context_{request.user.id}'
    context = cache.get(key)
    if not context:
        context = expensive_operation(request)
        cache.set(key, context, 60 * 5)  # 5 минут
    return context

# ✗ ПЛОХО: Медленные операции без кэша
def slow_context(request):
    # Это выполнится для каждого запроса!
    return {'data': database_query()}

Производительность

# ✓ ХОРОШО: Минимальные вычисления
def minimal_context(request):
    return {'year': 2025}  # O(1)

# ✗ ПЛОХО: Излишние вычисления
def heavy_context(request):
    # Это будет выполняться для КАЖДОГО шаблона!
    all_users = User.objects.all()  # O(n)
    all_posts = Post.objects.all()  # O(n)
    all_comments = Comment.objects.all()  # O(n)
    
    return {
        'users': all_users,
        'posts': all_posts,
        'comments': all_comments
    }

Заключение

Контекстные процессоры — это важный инструмент для:

  • DRY принцип: избегать повторения одних и тех же данных в каждом представлении
  • Глобальные данные: предоставить информацию, нужную всем шаблонам
  • Разделение ответственности: отделить логику получения данных от представлений
  • Масштабируемость: легко добавлять новые глобальные данные

Они критичны для построения поддерживаемых и масштабируемых веб-приложений на Django и других фреймворках.

Что такое контекстный процессор (context processor)? | PrepBro