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

# 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:')

    # ...

# 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}!')

# 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)

# 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.')

# 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)),
            ],
        ),
    ]

# 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}')

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

# 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__

# 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__

# 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)

# 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)

# 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)

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

from django.conf import settings


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

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

from django.core.files.uploadedfile import UploadedFile


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

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,
    )

from myapp.models import MyModel


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

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)

from django.test import RequestFactory

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

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

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

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

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


def my_function():
    value = 1000000


formatted_value = intcomma(value)
# Do something with formatted_value

from django.template.defaultfilters import floatformat


def my_function():
    value = 1000.123456


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

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

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

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

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

from django.template.base import Parser


def my_function():
    parser = Parser()


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

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

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

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

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