Django模板：无需修改模板，如何在指定变量后注入内容？

完全可以实现！不用修改现有模板的核心思路是在模板渲染前动态处理上下文变量，把你传入的content__post这类扩展变量自动合并到对应的位置，最终让模板输出符合预期的内容。下面给你几个实用的实现方案：

方案一：手动预处理上下文（简单直接） #

写一个辅助函数，在调用模板渲染前先处理上下文字典，自动把__post结尾的变量拼接到对应主变量的后面：

def prepare_extended_context(context):
    # 复制上下文避免修改原数据
    processed_context = context.copy()
    
    # 找出所有带__post后缀的变量
    post_extension_keys = [key for key in processed_context if key.endswith('__post')]
    
    for ext_key in post_extension_keys:
        # 拆分出主变量名（比如从content__post得到content）
        base_key = ext_key.rsplit('__post', 1)[0]
        if base_key in processed_context:
            # 将扩展内容拼接到主变量内容后（这里用空格分隔，可按需调整）
            processed_context[base_key] = f"{processed_context[base_key]} {processed_context[ext_key]}"
        # 移除扩展变量，避免模板渲染时出现未定义变量的问题
        del processed_context[ext_key]
    
    return processed_context

使用方式也很简单：

from django.template import Template

# 你的原始模板
template_str = "{{ header }} {{ content }} {{ footer }}"
# 原始上下文（包含扩展变量）
raw_context = dict(
    header='foo',
    content='bar',
    footer='blu',
    content__post='this should be between content and footer'
)
# 预处理上下文
processed_context = prepare_extended_context(raw_context)
# 渲染模板
result = Template(template_str).render(processed_context)
# 输出结果："foo bar this should be between content and footer blu"

方案二：自定义可扩展模板类（一劳永逸） #

如果项目里很多地方都需要这个功能，可以自定义一个继承自Django Template的子类，让它自动处理这类扩展变量，不用每次手动调用预处理函数：

from django.template import Template

class ExtendableTemplate(Template):
    def render(self, context):
        # 先处理上下文，再调用父类的渲染方法
        processed_context = self._process_extensions(context)
        return super().render(processed_context)
    
    def _process_extensions(self, context):
        # 处理Django的Context对象（比如RequestContext），转换成字典
        if hasattr(context, 'flatten'):
            context_dict = context.flatten()
        else:
            context_dict = dict(context)
        
        processed = context_dict.copy()
        
        # 处理__post后缀变量
        post_keys = [key for key in processed if key.endswith('__post')]
        for key in post_keys:
            base_key = key.rsplit('__post', 1)[0]
            if base_key in processed:
                processed[base_key] = f"{processed[base_key]} {processed[key]}"
            del processed[key]
        
        # 还可以扩展支持__pre前缀（在主变量前插入内容）
        pre_keys = [key for key in processed if key.endswith('__pre')]
        for key in pre_keys:
            base_key = key.rsplit('__pre', 1)[0]
            if base_key in processed:
                processed[base_key] = f"{processed[key]} {processed[base_key]}"
            del processed[key]
        
        return processed

使用时直接用这个自定义模板类：

template = ExtendableTemplate("{{ header }} {{ content }} {{ footer }}")
result = template.render(raw_context)
# 同样得到预期的输出

方案三：全局模板中间件（适合全项目生效） #

如果你的Django项目所有模板都需要支持这个功能，可以写一个模板中间件，在渲染前自动处理上下文。不过这个方案适合全局需求，需要在settings.py里注册中间件：

# 在你的app里创建middleware.py
from django.template.response import TemplateResponse

class TemplateExtensionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    
    def __call__(self, request):
        response = self.get_response(request)
        return response
    
    def process_template_response(self, request, response):
        if isinstance(response, TemplateResponse):
            # 预处理上下文
            processed_context = prepare_extended_context(response.context_data)
            response.context_data = processed_context
        return response

然后在settings.py的MIDDLEWARE里添加这个中间件：

MIDDLEWARE = [
    # ...其他中间件
    'yourapp.middleware.TemplateExtensionMiddleware',
]

这样所有视图返回的TemplateResponse都会自动处理这类扩展变量，完全不用修改视图和模板代码。

注意事项 #

• 拼接时的分隔符（比如空格）可以根据需求调整，比如改成换行或者其他符号。
• 如果需要支持更复杂的扩展规则（比如多个插入点），可以扩展预处理函数的逻辑，比如识别__insert_after_content这类更明确的命名。
• 如果上下文里的变量是HTML内容，记得确保渲染时不会被转义（比如用{{ content|safe }}，或者在预处理时把内容标记为安全）。

内容的提问来源于stack exchange，提问作者guettli