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/[email protected]
        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.',
        '[email protected]',
        ['[email protected]'],
        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類來註冊自定義