django数据库迁移 - 空想家的博客

好的，以下是一个完整的示例代码，用于创建一个使用 Poetry、Django、Django REST framework 和 PostgreSQL 的项目。这个示例将展示如何配置和使用这些工具，并生成和应用数据库迁移。

步骤 1: 创建和配置 Django 项目

首先，确保你已经安装了 Poetry 和 PostgreSQL，然后在命令行中执行以下步骤：

创建 Django 项目并配置 Poetry：

# 创建一个新的 Django 项目目录
mkdir my_django_project
cd my_django_project

# 使用 Poetry 创建虚拟环境
poetry init -n

# 安装 Django
poetry add django

# 创建 Django 项目
poetry run django-admin startproject my_project .

安装并配置 Django REST framework 和 PostgreSQL：

# 安装 Django REST framework 和 PostgreSQL 连接库
poetry add djangorestframework psycopg2-binary

# 在 settings.py 中配置 'rest_framework' 和数据库连接

编辑 my_project/settings.py 文件：

# my_project/settings.py

INSTALLED_APPS = [
    ...
    'rest_framework',
    'my_app',  # 添加你的应用
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my_database',  # 数据库名称
        'USER': 'my_user',      # 数据库用户名
        'PASSWORD': 'my_password',  # 数据库密码
        'HOST': 'localhost',    # 数据库主机地址
        'PORT': '5432',         # 数据库端口
    }
}

创建 Django 应用：

# 创建一个新的 Django 应用
poetry run python manage.py startapp my_app

步骤 2: 编写 Django 应用中的视图和模型

定义模型：

编辑 my_app/models.py 文件：

# my_app/models.py
from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

创建序列化器：

在 my_app 目录下创建 serializers.py 文件：

# my_app/serializers.py
from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'

定义视图：

编辑 my_app/views.py 文件：

# my_app/views.py
from rest_framework import generics
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelListView(generics.ListCreateAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

class MyModelDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

配置 URL 路由：

编辑 my_project/urls.py 文件：

# my_project/urls.py
from django.urls import path, include

urlpatterns = [
    path('api/', include('my_app.urls')),
]

在 my_app 目录下创建 urls.py 文件：

# my_app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('mymodel/', views.MyModelListView.as_view(), name='mymodel-list'),
    path('mymodel/<int:pk>/', views.MyModelDetailView.as_view(), name='mymodel-detail'),
]

步骤 3: 生成和应用数据库迁移

生成迁移文件并应用迁移：

# 生成迁移文件
poetry run python manage.py makemigrations

# 应用迁移
poetry run python manage.py migrate

步骤 4: 运行开发服务器

运行开发服务器：

poetry run python manage.py runserver

现在你可以打开浏览器并访问 http://127.0.0.1:8000/api/mymodel/ 来查看和操作 MyModel 数据。

完整的文件结构

以下是项目的文件结构：

my_django_project/
├── my_app/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations/
│   │   ├── __init__.py
│   ├── models.py
│   ├── serializers.py
│   ├── tests.py
│   ├── urls.py
│   └── views.py
├── my_project/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── pyproject.toml

这样你就有了一个完整的 Django 项目，它使用 Poetry 管理依赖，Django REST framework 提供 API 支持，PostgreSQL 作为数据库后端。你可以根据需要扩展和修改这个项目。

要在 Django 中自动生成数据库迁移并在迁移时初始化写入数据，可以按照以下步骤进行。这个过程包括创建和编辑迁移文件，以便在迁移应用时执行初始化数据的逻辑。

步骤 1: 创建模型和生成迁移文件

定义模型：

在 my_app/models.py 文件中定义你的模型：

# my_app/models.py
from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

生成迁移文件：

运行以下命令生成迁移文件：

poetry run python manage.py makemigrations

步骤 2: 编辑迁移文件以初始化数据

找到生成的迁移文件（通常位于 my_app/migrations/ 目录中），并编辑该文件以添加初始化数据的逻辑。

假设生成的迁移文件为 0001_initial.py：

# my_app/migrations/0001_initial.py
from django.db import migrations, models

def init_data(apps, schema_editor):
    MyModel = apps.get_model('my_app', 'MyModel')
    initial_data = [
        {'name': 'Item 1', 'description': 'Description for Item 1'},
        {'name': 'Item 2', 'description': 'Description for Item 2'},
        {'name': 'Item 3', 'description': 'Description for Item 3'},
    ]
    for data in initial_data:
        MyModel.objects.create(**data)

class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    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=100)),
                ('description', models.TextField()),
            ],
        ),
        migrations.RunPython(init_data),
    ]

步骤 3: 应用迁移

运行以下命令来应用迁移：

poetry run python manage.py migrate

完整项目示例

以下是项目的完整代码和配置示例：

文件结构：

my_django_project/
├── my_app/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations/
│   │   ├── __init__.py
│   │   └── 0001_initial.py
│   ├── models.py
│   ├── serializers.py
│   ├── tests.py
│   ├── urls.py
│   └── views.py
├── my_project/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── pyproject.toml

`my_project/settings.py`:

# my_project/settings.py

INSTALLED_APPS = [
    ...
    'rest_framework',
    'my_app',  # 添加你的应用
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my_database',  # 数据库名称
        'USER': 'my_user',      # 数据库用户名
        'PASSWORD': 'my_password',  # 数据库密码
        'HOST': 'localhost',    # 数据库主机地址
        'PORT': '5432',         # 数据库端口
    }
}

`my_app/models.py`:

# my_app/models.py
from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

`my_app/migrations/0001_initial.py`:

# my_app/migrations/0001_initial.py
from django.db import migrations, models

def init_data(apps, schema_editor):
    MyModel = apps.get_model('my_app', 'MyModel')
    initial_data = [
        {'name': 'Item 1', 'description': 'Description for Item 1'},
        {'name': 'Item 2', 'description': 'Description for Item 2'},
        {'name': 'Item 3', 'description': 'Description for Item 3'},
    ]
    for data in initial_data:
        MyModel.objects.create(**data)

class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    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=100)),
                ('description', models.TextField()),
            ],
        ),
        migrations.RunPython(init_data),
    ]

`my_app/views.py`:

# my_app/views.py
from rest_framework import generics
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelListView(generics.ListCreateAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

class MyModelDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

`my_app/serializers.py`:

# my_app/serializers.py
from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'

`my_app/urls.py`:

# my_app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('mymodel/', views.MyModelListView.as_view(), name='mymodel-list'),
    path('mymodel/<int:pk>/', views.MyModelDetailView.as_view(), name='mymodel-detail'),
]

`my_project/urls.py`:

# my_project/urls.py
from django.urls import path, include

urlpatterns = [
    path('api/', include('my_app.urls')),
]

运行项目

执行以下命令来运行项目：

# 生成迁移文件
poetry run python manage.py makemigrations

# 应用迁移并初始化数据
poetry run python manage.py migrate

# 运行开发服务器
poetry run python manage.py runserver

现在，你的 Django 项目已经设置完毕，并且在数据库迁移时会自动初始化数据。

在 Django 中，数据库迁移可以自动生成，并且可以在迁移时初始化写入数据。下面是完整的步骤和代码示例，展示如何生成迁移文件并在迁移时初始化数据。

步骤 1: 创建 Django 项目并配置 Poetry

首先，确保你已经安装了 Poetry 和 PostgreSQL，然后在命令行中执行以下步骤：

# 创建一个新的 Django 项目目录
mkdir my_django_project
cd my_django_project

# 使用 Poetry 创建虚拟环境
poetry init -n

# 安装 Django
poetry add django

# 创建 Django 项目
poetry run django-admin startproject my_project .

步骤 2: 安装并配置 Django REST framework 和 PostgreSQL

继续在命令行中执行以下步骤：

# 安装 Django REST framework 和 PostgreSQL 连接库
poetry add djangorestframework psycopg2-binary

# 在 settings.py 中配置 'rest_framework' 和数据库连接

编辑 my_project/settings.py 文件：

# my_project/settings.py

INSTALLED_APPS = [
    ...
    'rest_framework',
    'my_app',  # 添加你的应用
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my_database',  # 数据库名称
        'USER': 'my_user',      # 数据库用户名
        'PASSWORD': 'my_password',  # 数据库密码
        'HOST': 'localhost',    # 数据库主机地址
        'PORT': '5432',         # 数据库端口
    }
}

步骤 3: 创建 Django 应用

继续在命令行中执行以下步骤：

# 创建一个新的 Django 应用
poetry run python manage.py startapp my_app

步骤 4: 编写 Django 应用中的视图和模型

定义模型：

编辑 my_app/models.py 文件：

# my_app/models.py
from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

创建序列化器：

在 my_app 目录下创建 serializers.py 文件：

# my_app/serializers.py
from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'

定义视图：

编辑 my_app/views.py 文件：

# my_app/views.py
from rest_framework import generics
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelListView(generics.ListCreateAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

class MyModelDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

配置 URL 路由：

编辑 my_project/urls.py 文件：

# my_project/urls.py
from django.urls import path, include

urlpatterns = [
    path('api/', include('my_app.urls')),
]

在 my_app 目录下创建 urls.py 文件：

# my_app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('mymodel/', views.MyModelListView.as_view(), name='mymodel-list'),
    path('mymodel/<int:pk>/', views.MyModelDetailView.as_view(), name='mymodel-detail'),
]

步骤 5: 生成迁移文件并初始化数据

生成迁移文件：

poetry run python manage.py makemigrations my_app

编辑迁移文件以初始化数据：

找到生成的迁移文件（通常位于应用程序的 migrations 目录中），并编辑该文件。你可以在 operations 列表中添加一个 RunPython 操作，以执行初始化数据的逻辑。

# my_app/migrations/0001_initial.py
from django.db import migrations, models

def init_data(apps, schema_editor):
    MyModel = apps.get_model('my_app', 'MyModel')
    initial_data = [
        {'name': 'Item 1', 'description': 'Description for Item 1'},
        {'name': 'Item 2', 'description': 'Description for Item 2'},
        {'name': 'Item 3', 'description': 'Description for Item 3'},
    ]
    for data in initial_data:
        MyModel.objects.create(**data)

class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    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=100)),
                ('description', models.TextField()),
            ],
        ),
        migrations.RunPython(init_data),
    ]

运行迁移：

poetry run python manage.py migrate

步骤 6: 运行开发服务器

运行开发服务器：

poetry run python manage.py runserver

现在你可以打开浏览器并访问 http://127.0.0.1:8000/api/mymodel/ 来查看和操作 MyModel 数据。

完整的文件结构

以下是项目的文件结构：

my_django_project/
├── my_app/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations/
│   │   ├── 0001_initial.py
│   │   ├── __init__.py
│   ├── models.py
│   ├── serializers.py
│   ├── tests.py
│   ├── urls.py
│   └── views.py
├── my_project/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── pyproject.toml

通过上述步骤，你已经成功创建了一个 Django 项目，并在数据库迁移时自动写入初始数据。这样，当你运行迁移时，初始数据将被写入数据库。

在 Django 项目中，若要在数据库迁移时写入初始化数据，可以采用更加模块化和可扩展的方法。这样的方法不仅有利于维护和扩展，还可以避免在单一迁移文件中进行过多操作。

以下是一个推荐的、更可扩展的解决方案：

使用单独的数据迁移文件

将初始化数据迁移分离出来，放到一个单独的迁移文件中。这使得迁移文件更加清晰和易于维护。

步骤 1: 定义模型

确保你的模型定义已经完成。以下是一个示例模型：

# my_app/models.py

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()

    def __str__(self):
        return self.name

步骤 2: 创建初始迁移文件

运行以下命令以创建初始迁移文件：

poetry run python manage.py makemigrations my_app

步骤 3: 创建一个单独的数据迁移文件

运行以下命令以创建一个新的空迁移文件：

poetry run python manage.py makemigrations --empty --name initial_data my_app

这将创建一个空的迁移文件，你可以在其中添加初始化数据。

步骤 4: 编辑数据迁移文件以添加初始数据

找到生成的迁移文件（通常位于 my_app/migrations/0002_initial_data.py），并编辑该文件以包含 RunPython 操作。

# my_app/migrations/0002_initial_data.py

from django.db import migrations

def create_initial_data(apps, schema_editor):
    MyModel = apps.get_model('my_app', 'MyModel')
    initial_data = [
        {'name': 'Item 1', 'description': 'Description for Item 1'},
        {'name': 'Item 2', 'description': 'Description for Item 2'},
        {'name': 'Item 3', 'description': 'Description for Item 3'},
    ]
    for data in initial_data:
        MyModel.objects.create(**data)

class Migration(migrations.Migration):

    dependencies = [
        ('my_app', '0001_initial'),  # 依赖于初始迁移
    ]

    operations = [
        migrations.RunPython(create_initial_data),
    ]

步骤 5: 应用迁移

运行以下命令以应用迁移，并在数据库中创建模型和初始化数据：

poetry run python manage.py migrate

这样做的优点：

可维护性：将数据迁移和模型迁移分离，使得迁移文件更容易理解和维护。
可扩展性：如果将来需要添加更多的初始化数据或修改现有的数据，只需创建一个新的迁移文件，而不是修改现有的迁移文件。
清晰性：单独的数据迁移文件清晰地展示了数据的初始化过程，便于追踪和管理。

总结

通过将数据初始化迁移分离到单独的迁移文件中，可以使项目更加模块化、可维护和易于扩展。这种方法不仅适用于初始数据的插入，也适用于以后需要插入的其他初始化数据。

下面是一个完整的示例代码，包括创建序列化器和视图：

# my_app/serializers.py

from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'

# my_app/views.py

from rest_framework import generics
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelListCreateView(generics.ListCreateAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer

# my_app/urls.py

from django.urls import path
from .views import MyModelListCreateView

urlpatterns = [
    path('mymodels/', MyModelListCreateView.as_view(), name='mymodel-list-create'),
]

在这个示例中，我们假设 MyModel 是你的模型，具有一些字段，并且你想要一个用于列出和创建 MyModel 实例的 API 视图。MyModelSerializer 是序列化器，它将 MyModel 实例序列化为 JSON 格式的数据。MyModelListCreateView 是 API 视图，它继承自 Django REST Framework 的 ListCreateAPIView 类，该类提供了列出和创建 API 资源的功能。

记得在项目的主 URL 配置文件中包含这个应用程序的 URL 配置文件：

# my_project/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('my_app.urls')),
]

这样就完成了创建序列化器和视图的过程。通过这些代码，你可以在 api/mymodels/ 路径下访问列出和创建 MyModel 实例的 API。

如果数据表中存储的是正则表达式，并且你希望在模型中使用这些正则表达式进行校验，你可以创建一个自定义的校验器，在模型字段上使用该校验器，并在保存模型实例时应用该校验器。下面是一个示例：

# my_app/validators.py

import re
from django.core.exceptions import ValidationError

def validate_with_regex(value, regex):
    # 在这里实现校验逻辑
    # value 是字段的值，regex 是存储在数据表中的正则表达式

    if not re.match(regex, value):
        raise ValidationError('该值不符合正则表达式要求')

    # 如果校验成功，可以不返回任何内容

然后，在模型中使用这个自定义的校验器：

# my_app/models.py

from django.db import models
from .validators import validate_with_regex

class YourModel(models.Model):
    your_field = models.CharField(max_length=100, validators=[validate_with_regex])

    # 其他字段和方法...

在这个示例中，validate_with_regex 是一个自定义的校验器函数，它接受两个参数：value 是字段的值，regex 是存储在数据表中的正则表达式。校验器使用 re.match 函数来检查字段的值是否符合正则表达式的要求。如果不符合，则抛出 ValidationError 异常。

然后，将该校验器应用到你的模型字段上，只需在字段定义时将其添加到 validators 参数中即可。每当你尝试保存模型实例时，该校验器都会自动执行，并根据存储的正则表达式对字段的值进行校验。

这种方法使得你可以使用存储在数据库中的正则表达式来校验模型字段的值，同时也可以根据需要定义不同的校验逻辑。

将增删改查功能集成到序列化器中需要使用 Django REST Framework 的 ModelSerializer 类。虽然增删改查功能通常是在视图中处理，但你可以在序列化器中添加一些额外的方法来处理这些操作。以下是一个完整的示例代码，将增删改查功能集成到序列化器中，同时提供对应的视图和 URL 配置。

项目结构

your_project/
    your_app/
        migrations/
        __init__.py
        admin.py
        apps.py
        models.py
        serializers.py
        tests.py
        urls.py
        views.py
    your_project/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    manage.py

1. 设置项目

首先，创建 Django 项目和应用：

django-admin startproject your_project
cd your_project
python manage.py startapp your_app

2. 定义模型

在 your_app/models.py 中定义 Book 模型：

# your_app/models.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

    def __str__(self):
        return self.title

3. 创建序列化器

在 your_app/serializers.py 中创建 Book 模型的序列化器，集成增删改查功能：

# your_app/serializers.py

from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'published_date']

    def create(self, validated_data):
        return Book.objects.create(**validated_data)

    def update(self, instance, validated_data):
        instance.title = validated_data.get('title', instance.title)
        instance.author = validated_data.get('author', instance.author)
        instance.published_date = validated_data.get('published_date', instance.published_date)
        instance.save()
        return instance

    def delete(self, instance):
        instance.delete()

4. 创建视图

在 your_app/views.py 中创建视图：

# your_app/views.py

from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from .models import Book
from .serializers import BookSerializer

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

5. 配置 URL

在 your_app/urls.py 中配置路由：

# your_app/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import BookViewSet

router = DefaultRouter()
router.register(r'books', BookViewSet, basename='book')

urlpatterns = [
    path('', include(router.urls)),
]

在项目的 urls.py 中包含应用的 URL：

# your_project/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('your_app.urls')),
]

6. 创建数据迁移并初始化数据

首先，创建和应用数据库迁移：

python manage.py makemigrations
python manage.py migrate

然后，创建一个空迁移文件来初始化数据：

python manage.py makemigrations --empty your_app

编辑生成的迁移文件，添加初始化数据：

# your_app/migrations/000X_auto_YYYYMMDD_HHMM.py

from django.db import migrations

def initialize_books(apps, schema_editor):
    Book = apps.get_model('your_app', 'Book')
    Book.objects.create(title='Book 1', author='Author 1', published_date='2023-01-01')
    Book.objects.create(title='Book 2', author='Author 2', published_date='2023-02-01')

class Migration(migrations.Migration):

    dependencies = [
        ('your_app', 'previous_migration_file'),  # 替换为实际的依赖迁移文件
    ]

    operations = [
        migrations.RunPython(initialize_books),
    ]

运行迁移以应用更改并初始化数据：

python manage.py migrate

7. 编写测试用例

在 your_app/tests.py 中编写测试用例：

# your_app/tests.py

from django.test import TestCase
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APIClient
from .models import Book

class BookTests(TestCase):
    def setUp(self):
        self.client = APIClient()
        self.book_data = {'title': 'Test Book', 'author': 'Test Author', 'published_date': '2023-01-01'}
        self.book = Book.objects.create(**self.book_data)
    
    def test_create_book(self):
        response = self.client.post(reverse('book-list'), self.book_data, format='json')
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(Book.objects.count(), 2)
    
    def test_get_books(self):
        response = self.client.get(reverse('book-list'))
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 1)
    
    def test_get_single_book(self):
        response = self.client.get(reverse('book-detail', kwargs={'pk': self.book.pk}))
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['title'], self.book.title)
    
    def test_update_book(self):
        update_data = {'title': 'Updated Book', 'author': 'Updated Author', 'published_date': '2023-01-01'}
        response = self.client.put(reverse('book-detail', kwargs={'pk': self.book.pk}), update_data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.book.refresh_from_db()
        self.assertEqual(self.book.title, 'Updated Book')
    
    def test_delete_book(self):
        response = self.client.delete(reverse('book-detail', kwargs={'pk': self.book.pk}))
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
        self.assertEqual(Book.objects.count(), 0)

8. 运行测试

使用 Django 的测试命令运行测试用例：

python manage.py test

9. 配置 Django Admin

在 your_app/admin.py 中注册 Book 模型：

# your_app/admin.py

from django.contrib import admin
from .models import Book

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'published_date')
    search_fields = ('title', 'author')

10. 启动开发服务器

启动开发服务器以查看效果：

python manage.py runserver

访问 http://127.0.0.1:8000/admin/ 并使用超级用户帐户登录。如果还没有超级用户帐户，请创建一个：

python manage.py createsuperuser

总结

这个完整的示例项目展示了如何：

创建 Django 模型。
创建 Django REST Framework 的序列化器和视图，并在序列化器中处理增删改查功能。
配置 URL 路由。
使用迁移初始化数据库数据。
编写并运行测试用例。
注册模型到 Django 管理后台。
实现增删改查功能。

确保所有文件和路径名都与你的实际项目相匹配。如果遇到错误，请提供详细的错误信息以便进一步调试。

理解了，你的需求是有多个字段的模型，其中只有部分字段是 unique_together，你希望在初始化数据时检查这些字段的组合是否唯一，并在重复时进行更新，不重复时进行添加。

我们将使用一个更复杂的示例模型，并在 apps.py 中初始化数据，确保根据 unique_together 字段组合来进行检查。

示例模型

假设我们有一个 Book 模型，有多个字段，其中 title 和 author 字段组合是唯一的。

`books/models.py`

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13)
    pages = models.IntegerField()
    cover = models.CharField(max_length=100)
    language = models.CharField(max_length=30)

    class Meta:
        unique_together = ['title', 'author']

    def __str__(self):
        return f"{self.title} by {self.author}"

在 `apps.py` 中初始化数据

在 books/apps.py 中编写初始化逻辑，确保在应用启动时进行数据初始化。

`books/apps.py`

from django.apps import AppConfig

class BooksConfig(AppConfig):
    name = 'books'

    def ready(self):
        import django.db.utils
        try:
            self.initialize_data()
        except django.db.utils.OperationalError:
            # 数据库还没有准备好
            pass

    def initialize_data(self):
        from .models import Book
        from datetime import date
        
        # 定义初始化数据
        books_data = [
            {
                'title': 'Book One',
                'author': 'Author One',
                'published_date': date(2020, 1, 1),
                'isbn': '1234567890123',
                'pages': 200,
                'cover': 'Hardcover',
                'language': 'English'
            },
            {
                'title': 'Book Two',
                'author': 'Author Two',
                'published_date': date(2021, 6, 15),
                'isbn': '1234567890124',
                'pages': 300,
                'cover': 'Paperback',
                'language': 'Spanish'
            },
        ]
        
        # 遍历数据，使用 update_or_create 确保数据唯一且可更新
        for book_data in books_data:
            Book.objects.update_or_create(
                title=book_data['title'],
                author=book_data['author'],
                defaults=book_data
            )

配置应用

确保在 settings.py 中正确配置应用。

INSTALLED_APPS = [
    ...
    'books',
]

生成并应用数据库迁移

运行以下命令以生成并应用数据库迁移：

python manage.py makemigrations
python manage.py migrate

运行 Django 项目

启动 Django 项目，确保在启动时数据初始化逻辑正确执行。

python manage.py runserver

验证数据初始化

你可以通过 Django shell 验证数据是否正确初始化。

使用 Django shell 验证

python manage.py shell

from books.models import Book

# 列出所有书籍
for book in Book.objects.all():
    print(book.title, book.author, book.published_date, book.isbn, book.pages, book.cover, book.language)

这将显示数据库中的所有书籍，验证初始化逻辑是否按预期工作。

总结

这个示例展示了如何在 apps.py 中初始化数据，并确保在重复运行时对 unique_together 字段（在此示例中为 title 和 author）进行检查，重复的数据会更新，不重复的数据会添加。通过这种方式，你可以确保在 Django 项目启动时数据的一致性和完整性。

感谢你的进一步说明。如果模型中只有字段和 verbose_name，并且 admin.py 中只显示字段，却依然在 Django admin 页面中点击查看时报错，这可能是由于某些特定数据或配置的问题。下面是一些步骤来排查和解决问题。

排查步骤

检查数据库中的数据：

确保数据库中的所有数据都是有效的，并且字段值符合模型定义的要求。

# 启动 Django shell
python manage.py shell

# 导入模型并检查数据
from my_app.models import MyModel
for obj in MyModel.objects.all():
    print(obj.name)  # 替换为你的字段名，确保没有异常数据

确保迁移正确：

确保所有的数据库迁移都已正确应用：
```
python manage.py makemigrations
python manage.py migrate
```

检查模型定义：

确保模型定义中没有问题，特别是 verbose_name 的用法：

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100, verbose_name='Name')
    description = models.TextField(verbose_name='Description')

    class Meta:
        verbose_name = 'My Model'
        verbose_name_plural = 'My Models'

检查 Admin 配置：

确保在 admin.py 中正确配置了模型：

from django.contrib import admin
from .models import MyModel
   
@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'description')

获取详细错误信息

为了获取更多详细的错误信息，可以在 Django 的 settings.py 文件中启用 DEBUG 模式，并查看错误日志：

# settings.py
DEBUG = True

然后重现错误，查看浏览器中的详细错误信息，或者在终端中查看 Django 的错误日志。

示例代码

确保你的模型和 Admin 配置如下：

models.py

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100, verbose_name='Name')
    description = models.TextField(verbose_name='Description')

    class Meta:
        verbose_name = 'My Model'
        verbose_name_plural = 'My Models'

admin.py

from django.contrib import admin
from .models import MyModel

@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'description')

调试

如果上述步骤仍然无法解决问题，可以在 admin.py 中添加日志记录或打印信息来帮助调试：

from django.contrib import admin
from .models import MyModel

@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'description')

    def changelist_view(self, request, extra_context=None):
        try:
            return super().changelist_view(request, extra_context=extra_context)
        except Exception as e:
            print(f"Error in changelist_view: {e}")
            raise

    def change_view(self, request, object_id, form_url='', extra_context=None):
        try:
            return super().change_view(request, object_id, form_url, extra_context)
        except Exception as e:
            print(f"Error in change_view: {e}")
            raise

通过这些步骤和方法，你应该能够找到并解决在 Django admin 页面中点击查看时报错的问题。如果问题依旧存在，请提供详细的错误信息，以便进一步诊断和解决。

步骤 1: 创建和配置 Django 项目

步骤 2: 编写 Django 应用中的视图和模型

步骤 3: 生成和应用数据库迁移

步骤 4: 运行开发服务器

完整的文件结构

步骤 1: 创建模型和生成迁移文件

步骤 2: 编辑迁移文件以初始化数据

步骤 3: 应用迁移

完整项目示例

文件结构：

my_project/settings.py:

my_app/models.py:

my_app/migrations/0001_initial.py:

my_app/views.py:

my_app/serializers.py:

my_app/urls.py:

my_project/urls.py:

运行项目

步骤 1: 创建 Django 项目并配置 Poetry

步骤 2: 安装并配置 Django REST framework 和 PostgreSQL

步骤 3: 创建 Django 应用

步骤 4: 编写 Django 应用中的视图和模型

步骤 5: 生成迁移文件并初始化数据

步骤 6: 运行开发服务器

完整的文件结构

使用单独的数据迁移文件

步骤 1: 定义模型

步骤 2: 创建初始迁移文件

步骤 3: 创建一个单独的数据迁移文件

步骤 4: 编辑数据迁移文件以添加初始数据

步骤 5: 应用迁移

这样做的优点：

总结

项目结构

1. 设置项目

2. 定义模型

3. 创建序列化器

4. 创建视图

5. 配置 URL

6. 创建数据迁移并初始化数据

7. 编写测试用例

8. 运行测试

9. 配置 Django Admin

10. 启动开发服务器

总结

示例模型

books/models.py

在 apps.py 中初始化数据

books/apps.py

配置应用

生成并应用数据库迁移

运行 Django 项目

验证数据初始化

使用 Django shell 验证

总结

排查步骤

获取详细错误信息

示例代码

models.py

admin.py

调试

FEATURED TAGS

FRIENDS

`my_project/settings.py`:

`my_app/models.py`:

`my_app/migrations/0001_initial.py`:

`my_app/views.py`:

`my_app/serializers.py`:

`my_app/urls.py`:

`my_project/urls.py`:

`books/models.py`

在 `apps.py` 中初始化数据

`books/apps.py`