Django 自定义管理命令：从入门到高级

---

title: Django 自定义管理命令：从入门到高级

date: 2024/5/16 18:34:29

updated: 2024/5/16 18:34:29

categories:

• 后端开发

tags:

• Django
• 自定义命令
• 入门教程
• 高级技巧
• 命令创建
• 命令使用
• 自定义管理

---

第 1 章 简介

1.1 Django 管理命令简介

Django 是一个流行的 Python 网络框架，提供了许多有用的工具和特性，帮助开发人员快速构建强大的 Web

应用程序。其中一项重要特性是管理命令，它允许您在命令行界面 (CLI) 中执行各种任务，如数据库迁移、数据库操作、缓存清理和其他系统管理任务。

1.2 Django 管理命令的优势

• 易于扩展：您可以轻松地创建自定义管理命令，以满足您的项目需求。
• 一致的用户界面：管理命令使用一致的用户界面，这使得学习和使用管理命令变得更加简单。
• 易于集成：管理命令可以很容易地集成到您的 CI/CD 管道中，以实现自动化部署和测试。
• 易于调试：管理命令可以帮助您快速调试和诊断问题，而无需打开 IDE 或使用其他调试工具。

1.3 内置管理命令的结构

Django 提供了许多内置管理命令，这些命令可以帮助您执行各种任务。例如，makemigrations和migrate

命令用于数据库迁移，createsuperuser命令用于创建管理员用户，runserver命令用于启动开发服务器。

AD：首页 | 一个覆盖广泛主题工具的高效在线平台

下面是一个内置管理命令的示例，名为inspectdb：

# myapp/management/commands/inspectdb.py

from django.core.management.base import BaseCommand
from django.db.connection import DatabaseWrapper

class Command(BaseCommand):
    help = 'Prints the models that would be created by inspecting the '
           'database tables.'

    def add_arguments(self, parser):
        parser.add_argument('appname', nargs='?',
                            type=str, default='',
                            help='App name to inspect (optional).')

    def handle(self, *args, **options):
        db = DatabaseWrapper(connections['default'])

        if options['appname']:
            self.stdout.write('Inspecting database for app "%s"...' %
                              options['appname'])
        else:
            self.stdout.write('Inspecting all apps...')

        # ...

        self.stdout.write('The following models would be created:')

        # ...

在这个示例中，我们可以看到内置管理命令的基本结构。它包括以下几个部分：

• import语句：导入所需的模块。
• Command类：继承自django.core.management.base.BaseCommand类，定义自定义管理命令的行为。
• add_arguments方法：定义管理命令的选项和参数。
• handle方法：定义管理命令的主要逻辑。

第 2 章 创建自定义管理命令

2.1 创建一个简单的管理命令

在 Django 中创建自定义管理命令非常简单。首先，您需要在您的应用目录下创建一个名为management/commands的目录。在这个目录中，您可以创建一个

Python 文件，文件名就是您的管理命令名。例如，如果您想创建一个名为greet的管理命令，您可以在management/commands

目录下创建一个名为greet.py的文件。

下面是一个简单的greet管理命令的示例：

# myapp/management/commands/greet.py

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'Greets the user'

    def add_arguments(self, parser):
        parser.add_argument('name', type=str, help='The name of the person to greet')

    def handle(self, *args, **options):
        name = options['name']
        self.stdout.write(f'Hello, {name}!')

在这个示例中，我们创建了一个名为greet的管理命令，它接受一个名为name的参数，并打印出一条问候信息。

2.2 探索不同类型的选项和参数

Django 管理命令支持多种类型的选项和参数。您可以使用add_arguments方法来定义这些选项和参数。

AD：专业搜索引擎

• 位置参数：这些参数没有前缀，直接跟在命令后面。在上面的示例中，name就是一个位置参数。
• 选项：这些参数以--或-开头，可以有值，也可以没有值。例如，--verbosity就是一个选项，它控制命令的详细程度。

下面是一个带有选项的管理命令示例：

# myapp/management/commands/greet.py

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'Greets the user'

    def add_arguments(self, parser):
        parser.add_argument('name', type=str, help='The name of the person to greet')
        parser.add_argument('--upper', action='store_true', help='Convert the greeting to uppercase')

    def handle(self, *args, **options):
        name = options['name']
        greeting = f'Hello, {name}!'
        if options['upper']:
            greeting = greeting.upper()
        self.stdout.write(greeting)

在这个示例中，我们添加了一个名为--upper的选项，它将问候信息转换为大写字母。

第 3 章 使用 Django ORM

3.1 在自定义管理命令中使用 Django ORM 进行数据库操作

Django 提供了一个强大的对象关系映射（ORM）框架，使我们可以在 Python 代码中进行数据库操作。在自定义管理命令中使用 Django ORM

非常简单。首先，您需要导入您的模型。然后，您可以使用模型的 API 进行查询、创建、更新和删除操作。

下面是一个使用 Django ORM 创建一个新用户的示例：

# myapp/management/commands/create_user.py

from django.core.management.base import BaseCommand
from django.contrib.auth.models import User

class Command(BaseCommand):
    help = 'Create a new user'

    def add_arguments(self, parser):
        parser.add_argument('username', type=str, help='The username of the new user')
        parser.add_argument('--email', type=str, help='The email of the new user')
        parser.add_argument('--password', type=str, help='The password of the new user')

    def handle(self, *args, **options):
        username = options['username']
        email = options['email']
        password = options['password']

        user = User.objects.create_user(username, email, password)
        self.stdout.write(f'User {user.username} created successfully.')

在这个示例中，我们创建了一个名为create_user的管理命令，它接受一个名为username的位置参数，以及一个名为--email

和--password的选项。我们使用 Django ORM 的create_user方法创建了一个新用户。

3.2 探索数据迁移与自定义管理命令的关系

数据迁移是 Django 中管理数据库结构的一种机制。在自定义管理命令中，您可以使用数据迁移来执行数据库结构的更改。

AD：漫画首页

首先，您需要创建一个新的数据迁移文件。您可以使用 Django 的makemigrations命令来创建一个新的数据迁移文件。

python manage.py makemigrations myapp

在这个命令中，myapp是您的应用名称。这个命令将创建一个新的数据迁移文件，文件名类似于0001_initial.py。

接下来，您可以在这个文件中编写您的数据迁移代码。

下面是一个简单的数据迁移示例：

# myapp/migrations/0001_initial.py

from django.db import migrations

class Migration(migrations.Migration):
    dependencies = [
        ('myapp', '__first__'),
    ]

    operations = [
        migrations.CreateModel(
            name='MyModel',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=255)),
            ],
        ),
    ]

在这个示例中，我们创建了一个名为MyModel的新模型。

最后，您可以使用 Django 的migrate命令来执行数据迁移。

python manage.py migrate myapp

在这个命令中，myapp是您的应用名称。这个命令将执行数据迁移，并更新数据库结构。

第 4 章 处理输入和输出

4.1 学习如何处理用户输入和控制输出格式

在 Django 中处理用户输入和输出非常简单。在自定义管理命令中，您可以使用argparse模块来处理用户输入，并使用 Python

标准库中的print和format函数来控制输出格式。

下面是一个使用argparse模块处理用户输入的示例：

# myapp/management/commands/my_command.py

from django.core.management.base import BaseCommand
import argparse

class Command(BaseCommand):
    help = 'My command'

    def add_arguments(self, parser):
        parser.add_argument('input', type=int, help='The input value')

    def handle(self, *args, **options):
        input_value = options['input']

        # Do something with input_value

        self.stdout.write(f'Input value: {input_value}')

在这个示例中，我们创建了一个名为my_command的管理命令，它接受一个名为input的位置参数。我们使用argparse

模块的add_argument方法来定义这个参数。

接下来，我们可以使用format函数来控制输出格式。

self.stdout.write(f'Input value: {input_value}')

在这个示例中，我们使用format函数将输入值格式化为字符串，并使用stdout.write方法将输出写入控制台。

4.2 探索如何将输出重定向到文件或管道中

在 Django 中，您可以将输出重定向到文件或管道中。这可以使用 Python 标准库中的sys.stdout和sys.stderr对象来实现。

下面是一个将输出重定向到文件的示例：

# myapp/management/commands/my_command.py

import sys

# ...

def handle(self, *args, **options):
    # Save stdout to a file
    with open('output.txt', 'w') as f:
        sys.stdout = f

        # Do something

        self.stdout.write('Hello, world!')

        # Restore stdout
        sys.stdout = sys.__stdout__

在这个示例中，我们使用sys.stdout对象将输出重定向到一个文件中。首先，我们将sys.stdout

对象重定向到一个文件对象。然后，我们可以使用stdout.write方法将输出写入文件。最后，我们将sys.stdout对象重定向回控制台。

同样，我们可以将输出重定向到管道中。

# myapp/management/commands/my_command.py

import sys

# ...

def handle(self, *args, **options):
    # Send output to a pipe
    sys.stdout = sys.stdout.buffer

    # Do something

    self.stdout.write(b'Hello, world!')

    # Restore stdout
    sys.stdout = sys.__stdout__

在这个示例中，我们将sys.stdout对象重定向到一个管道中。首先，我们将sys.stdout

对象重定向到一个缓冲区对象。然后，我们可以使用stdout.write方法将输出写入管道。最后，我们将sys.stdout对象重定向回控制台。

第 5 章 模拟 Django 内置命令

5.1 学习如何模拟 Django 内置命令的行为，如makemigrations和migrate

要模拟 Django 内置命令的行为，例如makemigrations和migrate，您可以创建自定义的管理命令，并在其中调用 Django 内置命令的相应功能。

以下是一个示例，演示如何模拟makemigrations命令：

# myapp/management/commands/mymakemigrations.py

from django.core.management.commands import makemigrations

class Command(makemigrations.Command):
    help = 'Custom makemigrations command'

    def handle(self, *args, **options):
        # Your custom code here

        super().handle(*args, **options)

在这个示例中，我们创建了一个名为mymakemigrations的自定义管理命令，并继承了 Django 内置命令makemigrations.Command

。在handle方法中，您可以添加您自己的逻辑，然后调用super().handle(*args, **options)来执行原始的makemigrations命令。

您可以按照类似的方式模拟migrate命令或其他 Django 内置命令。

5.2 探索如何扩展现有的内置命令

要扩展现有的内置命令，您可以创建一个新的管理命令，并在其中添加自定义的功能或选项。

以下是一个示例，演示如何扩展showmigrations命令：

# myapp/management/commands/myshowmigrations.py

from django.core.management.commands import showmigrations

class Command(showmigrations.Command):
    help = 'Custom showmigrations command'

    def add_arguments(self, parser):
        super().add_arguments(parser)
        parser.add_argument(
            '--app', dest='app', default=None,
            help='Show only migrations for a specific app',
        )

    def handle(self, *args, **options):
        app = options.get('app')

        if app:
        # Show only migrations for the specified app
        # Your custom code here
        else:
            super().handle(*args, **options)

在这个示例中，我们创建了一个名为myshowmigrations的自定义管理命令，并扩展了showmigrations.Command

。我们通过覆盖add_arguments方法添加了一个新的选项--app，用于指定要显示迁移的应用程序。在handle

方法中，我们检查是否指定了应用程序，并根据需要添加自定义逻辑。

通过类似的方式，您可以扩展和定制任何其他 Django 内置命令，以满足您的特定需求。

第 6 章 在生产环境中使用自定义管理命令

6.1 学习如何在生产环境中安全地使用自定义管理命令

在生产环境中使用自定义管理命令时，需要特别注意安全性和稳定性。以下是一些最佳实践：

• 测试：在将自定义命令部署到生产环境之前，确保在开发或测试环境中对其进行了彻底的测试。
• 权限：确保执行管理命令的用户具有适当的权限，并且不会因为执行命令而暴露敏感数据或系统资源。
• 日志记录：在命令中实现详细的日志记录，以便在出现问题时可以追踪和诊断。
• 错误处理：确保命令能够妥善处理错误，避免因为单个错误导致整个应用程序崩溃。
• 监控：监控命令的执行情况，确保它们按照预期运行，并在出现问题时及时通知。

6.2 探索如何通过 Django 管理界面触发管理命令

Django 管理界面本身不直接支持触发管理命令，但您可以通过创建自定义的管理操作来实现类似的功能。以下是一个简单的示例，说明如何创建一个管理操作来触发自定义管理命令：

首先，创建一个自定义管理命令：

# myapp/management/commands/mycommand.py

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'My custom command'

    def handle(self, *args, **options):
        # Your custom command logic here
        pass

然后，在您的模型管理类中创建一个自定义操作：

# myapp/admin.py

from django.contrib import admin
from django.core.management import call_command

class MyModelAdmin(admin.ModelAdmin):
    actions = ['action_mycommand']

    def action_mycommand(self, request, queryset):
        # Call the custom command
        call_command('mycommand')

    action_mycommand.short_description = "Run my custom command"

admin.site.register(MyModel, MyModelAdmin)

在这个示例中，我们创建了一个名为action_mycommand的管理操作，它调用了我们之前创建的自定义管理命令mycommand。用户可以通过

Django 管理界面的操作菜单选择这个操作来触发命令。

请注意，这种方法需要谨慎使用，因为它允许通过管理界面直接执行命令，可能会带来安全风险。确保只有受信任的用户可以访问管理界面，并且命令的执行不会对生产环境造成不利影响。

第 7 章 进阶主题

7.1 学习如何在多线程或分布式环境中使用自定义管理命令

在多线程或分布式环境中使用自定义管理命令需要特别注意，以避免并发问题和数据不一致。以下是一些最佳实践：

• 锁定：在执行管理命令时，使用数据库锁定或其他同步机制来确保在同一时间只有一个进程/线程可以执行命令。
• 分片：如果您的应用程序在多个数据库实例中分片数据，请确保在执行管理命令时能够正确处理分片。
• 日志记录：在命令中实现详细的日志记录，以便在出现问题时可以追踪和诊断。
• 错误处理：确保命令能够妥善处理错误，避免因为单个错误导致整个应用程序崩溃。

7.2 探索如何将自定义管理命令集成到 CI/CD 管道中

将自定义管理命令集成到 CI/CD 管道中可以自动化部署过程，并确保每次部署都经过完整的测试和验证。以下是将自定义管理命令集成到

CI/CD 管道中的一般步骤：

1. 将管理命令添加到版本控制：将自定义管理命令的源代码添加到版本控制系统中，以便在每次部署时都能够访问它。
2. 在 CI 环节中执行测试：在构建过程中，运行测试套件，确保自定义管理命令已通过完整的测试。
3. 在 CD 环节中执行部署：在部署过程中，使用自定义管理命令执行部署任务，例如数据库迁移、缓存清除、数据清理等。

具体实现方法取决于您使用的 CI/CD 工具和部署方法。以下是一个使用 GitHub Actions 和 Django 部署到 Heroku 的示例：

# .github/workflows/deploy.yml

name: Deploy

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.9

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run tests
        run: python manage.py test

      - name: Deploy to Heroku
        uses: akhileshns/heroku-deploy@v3.10.1
        with:
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          app_name: myapp
          deploy_branch: main
          buildpack: heroku/python
          config_vars: |
            DJANGO_SETTINGS_MODULE=myapp.settings.production
            SECRET_KEY=${{ secrets.SECRET_KEY }}
          add_dot_env: false
          python_version: python-3.9.2
          install_command: pip install -r requirements.txt
          migration_command: python manage.py migrate
          release_command: python manage.py mycommand

在这个示例中，我们使用 GitHub Actions 构建一个 CI/CD 管道，在部署到 Heroku 时执行数据库迁移和自定义管理命令mycommand

。请根据您的实际需求进行修改。

附录

参考资料

1. Django 文档 - 自定义管理命令：https://docs.djangoproject.com/en/4.0/howto/custom-management-commands/
2. Heroku 文档 - Python 构建包：https://devcenter.heroku.com/articles/python-support#buildpack-detect-and-build
3. GitHub Actions 文档 - Heroku 部署动作：https://github.com/marketplace/actions/deploy-to-heroku

常见问答

Q: 在多线程或分布式环境中，如何确保自定义管理命令的原子性？

A: 可以使用数据库事务或其他同步机制来确保自定义管理命令的原子性。在执行命令时，首先开始一个事务，然后在事务中执行命令。如果命令成功完成，则提交事务；如果命令失败，则回滚事务。

Q: 如何在自定义管理命令中处理命令行参数？

A: 可以使用 Django 的argparse模块来处理命令行参数。在自定义管理命令中，可以使用parser.add_argument

函数添加一个参数，然后使用parser.parse_args函数获取参数值。例如：

from django.core.management.base import BaseCommand
import argparse

class Command(BaseCommand):
    help = 'My custom command'

    def add_arguments(self, parser):
        parser.add_argument('--my-param', type=int, help='My custom parameter')

    def handle(self, *args, **options):
        my_param = options['my_param']
        # Do something with my_param

Q: 如何在自定义管理命令中访问 Django 设置？

A: 可以使用django.conf模块中的settings变量来访问 Django 设置。例如：

from django.conf import settings

def my_function():
    secret_key = settings.SECRET_KEY
    # Do something with secret_key

Q: 如何在自定义管理命令中访问数据库？

A: 可以使用 Django 的django.db模块中的connections变量来访问数据库。例如：

from django.db import connections

def my_function():
    with connections['default'].cursor() as cursor:
        cursor.execute('SELECT * FROM myapp_mymodel')
        rows = cursor.fetchall()
        # Do something with rows

Q: 如何在自定义管理命令中处理文件上传？

A: 可以使用 Django 的django.core.files.uploadedfile模块中的UploadedFile类来处理文件上传。例如：

from django.core.files.uploadedfile import UploadedFile

def my_function(file):
    with UploadedFile(file, name='myfile.txt') as f:
# Do something with f

Q: 如何在自定义管理命令中发送电子邮件？

A: 可以使用 Django 的django.core.mail模块中的send_mail函数来发送电子邮件。例如：

from django.core.mail import send_mail

def my_function():
    send_mail(
        'Subject here',
        'Here is the message.',
        'from@example.com',
        ['to@example.com'],
        fail_silently=False,
    )

Q: 如何在自定义管理命令中使用 Django 模型？

A: 可以使用 Django 的django.db.models模块中的Model类来使用 Django 模型。例如：

from myapp.models import MyModel

def my_function():
    obj = MyModel.objects.get(id=1)
    # Do something with obj

Q: 如何在自定义管理命令中使用 Django 视图和模板？

A: 在自定义管理命令中，不能直接使用 Django 视图和模板。但是，可以使用 Django 的django.shortcuts模块中的render

函数来渲染一个模板，并返回一个 HTTP 响应。然后，可以使用 Django 的django.http模块中的HttpResponse类来返回该响应。例如：

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

def my_function():
    context = {'my_var': 'Hello, world!'}
    response = render(request, 'mytemplate.html', context)
    return HttpResponse(response.content)

注意：在这个示例中，request变量是一个假的HttpRequest对象，可以使用django.test.RequestFactory类来创建。例如：

from django.test import RequestFactory

request = RequestFactory().get('/')

Q: 如何在自定义管理命令中使用 Django 缓存？

A: 可以使用 Django 的django.core.cache模块中的cache函数来使用 Django 缓存。例如：

from django.core.cache import cache

def my_function():
    cache.set('my_key', 'my_value', 3600)
    value = cache.get('my_key')
    # Do something with value

Q: 如何在自定义管理命令中使用 Django 签名？

A: 可以使用 Django 的django.core.signing模块中的dumps和loads函数来使用 Django 签名。例如：

from django.core.signing import dumps, loads

def my_function():
    data = {'my_var': 'Hello, world!'}
    signed_data = dumps(data)
    loaded_data = loads(signed_data)
    # Do something with loaded_data

Q: 如何在自定义管理命令中使用 Django 会话？

A: 可以使用 Django 的django.contrib.sessions模块中的SessionStore类来使用 Django 会话。例如：

from django.contrib.sessions.backends.db import SessionStore

def my_function():
    session = SessionStore()
    session['my_key'] = 'my_value'
    session.save()
    value = session.get('my_key')
    # Do something with value

Q: 如何在自定义管理命令中使用 Django 过滤器？

A: 可以使用 Django 的django.contrib.humanize模块中的过滤器来格式化数据。例如：

from django.contrib.humanize.templatetags.humanize import intcomma

def my_function():

    value = 1000000
formatted_value = intcomma(value)
# Do something with formatted_value

Q: 如何在自定义管理命令中使用 Django 模板标签？

A: 可以使用 Django 的django.template.defaultfilters模块中的模板标签来格式化数据。例如：

from django.template.defaultfilters import floatformat

def my_function():

    value = 1000.123456
formatted_value = floatformat(value, 2)
# Do something with formatted_value

Q: 如何在自定义管理命令中使用 Django 模板过滤器？

A: 可以使用 Django 的django.template.context_processors模块中的模板过滤器来格式化数据。例如：

from django.template.context_processors import csrf

def my_function():

    request = ...  # Assume this is a valid HttpRequest object
context = {}
context.update(csrf(request))
formatted_value = context['csrf_token']
# Do something with formatted_value

Q: 如何在自定义管理命令中使用 Django 模板上下文处理器？

A: 可以使用 Django 的django.template.context_processors模块中的模板上下文处理器来向模板上下文中添加变量。例如：

from django.contrib.auth.context_processors import auth

def my_function():

    request = ...  # Assume this is a valid HttpRequest object
context = {}
context.update(auth(request))
user = context['user']
# Do something with user

Q: 如何在自定义管理命令中使用 Django 模板加载器？

A: 可以使用 Django 的django.template.loaders.app_directories.Loader类来加载模板。例如：

from django.template.loader import Loader

def my_function():

    loader = Loader()
template = loader.get_template('myapp/mytemplate.html')
context = {'my_var': 'Hello, world!'}
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板引擎？

A: 可以使用 Django 的django.template.Engine类来渲染模板。例如：

from django.template import Engine

def my_function():

    engine = Engine()
template = engine.get_template('myapp/mytemplate.html')
context = {'my_var': 'Hello, world!'}
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板解析器？

A: 可以使用 Django 的django.template.base模块中的模板解析器来解析模板。例如：

from django.template.base import Parser

def my_function():

    parser = Parser()
template = parser.parse('myapp/mytemplate.html')
# Do something with template

Q: 如何在自定义管理命令中使用 Django 模板标签库？

A: 可以使用 Django 的django.template.defaulttags模块中的模板标签库来注册模板标签。例如：

from django.template.defaulttags import register

@register.simple_tag
def my_tag(value):

    return 'Hello, {}!'.format(value)

def my_function():

    from django.template import Template, Context

template = Template('{% load mytags %}{{ value|my_tag }}')
context = Context({'value': 'world'})
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板过滤器库？

A: 可以使用 Django 的django.template.defaultfilters模块中的模板过滤器库来注册模板过滤器。例如：

from django.template.defaultfilters import register

@register.filter
def my_filter(value):

    return 'Hello, {}!'.format(value)

def my_function():

    from django.template import Template, Context

template = Template('{{ value|my_filter }}')
context = Context({'value': 'world'})
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板自定义标签？

A: 可以使用 Django 的django.template.base模块中的Library类来注册自定义标签。例如：

from django.template.base import Library

register = Library()

@register.inclusion_tag('myapp/mytag.html')
def my_tag(value):

    return {'value': value}

def my_function():

    from django.template import Template, Context

template = Template('{% load mytags %}{% my_tag "world" %}')
context = Context()
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板自定义过滤器？

A: 可以使用 Django 的django.template.base模块中的Library类来注册自定义过滤器。例如：

from django.template.base import Library

register = Library()

@register.filter
def my_filter(value):

    return 'Hello, {}!'.format(value)

def my_function():

    from django.template import Template, Context

template = Template('{{ "world"|my_filter }}')
context = Context()
html = template.render(context)
# Do something with html

Q: 如何在自定义管理命令中使用 Django 模板自定义SimpleTag？

A: 可以使用 Django 的django.template.base模块中的Library类和SimpleTag类来注册自定义