DRF中DictField与ListField的深度解析与应用实践

1. 为什么需要DictField和ListField？

在DRF（Django REST Framework）开发中，我们经常遇到需要处理复杂数据结构的情况。比如一个电商平台的商品详情接口，可能需要返回包含规格参数、图片列表、SKU信息等嵌套结构的数据。传统的CharField、IntegerField等基础字段类型显然无法满足这种需求。

这就是DictField和ListField的价值所在。它们允许我们：

• 直接处理Python原生的字典和列表结构
• 无需额外的序列化/反序列化代码
• 保持数据的原始结构完整性
• 支持嵌套的复杂数据结构

举个例子，如果我们用传统方式处理一个包含标签列表的博客文章模型，代码会变得非常冗长：

python复制# 传统方式 - 需要单独处理每个标签
class ArticleSerializer(serializers.Serializer):
    title = serializers.CharField()
    content = serializers.CharField()
    tag1 = serializers.CharField(required=False)
    tag2 = serializers.CharField(required=False)
    tag3 = serializers.CharField(required=False)
    # ...

而使用ListField后，代码会简洁很多：

python复制# 使用ListField - 直接处理标签列表
class ArticleSerializer(serializers.Serializer):
    title = serializers.CharField()
    content = serializers.CharField()
    tags = serializers.ListField(child=serializers.CharField())

提示：虽然DictField和ListField很强大，但它们不适合替代所有场景。对于有固定结构的数据，仍然建议使用嵌套的Serializer类。

2. DictField的深度解析与应用

2.1 DictField基础用法

DictField用于处理键值对形式的字典数据。它的基本定义非常简单：

python复制from rest_framework import serializers

extra_info = serializers.DictField(
    child=serializers.CharField()  # 指定字典值的类型
)

这个字段会：

• 验证输入是否为字典类型
• 验证所有值是否符合child参数指定的类型
• 在序列化和反序列化时保持字典结构不变

2.2 实际应用案例

假设我们正在开发一个电商系统，商品可能有动态属性：

python复制class ProductSerializer(serializers.ModelSerializer):
    attributes = serializers.DictField(
        child=serializers.CharField(),
        allow_empty=True,
        required=False
    )
    
    class Meta:
        model = Product
        fields = ['id', 'name', 'price', 'attributes']

这样我们就可以处理如下的商品数据：

json复制{
    "id": 1,
    "name": "智能手机",
    "price": 2999,
    "attributes": {
        "color": "黑色",
        "memory": "128GB",
        "weight": "175g"
    }
}

2.3 高级配置选项

DictField提供了多个有用的配置参数：

• child：指定字典值的字段类型（必须）
• allow_empty：是否允许空字典（默认True）
• required：是否为必填字段（默认True）
• default：默认值
• validators：自定义验证器

一个更复杂的例子：

python复制attributes = serializers.DictField(
    child=serializers.IntegerField(min_value=0, max_value=100),
    allow_empty=False,
    required=True,
    validators=[validate_attribute_keys],
    default={'default_key': 0}
)

注意：DictField不会验证字典的键（key），只验证值（value）。如果需要验证键，需要使用自定义验证器。

3. ListField的全面指南

3.1 ListField基础用法

ListField用于处理列表/数组类型的数据。基本定义如下：

python复制from rest_framework import serializers

tags = serializers.ListField(
    child=serializers.CharField(max_length=50),
    min_length=1,
    max_length=10
)

这个字段会：

• 验证输入是否为列表类型
• 验证所有元素是否符合child参数指定的类型
• 验证列表长度是否符合要求
• 保持列表结构不变

3.2 实际应用案例

考虑一个博客系统，文章可以有多个标签：

python复制class ArticleSerializer(serializers.ModelSerializer):
    tags = serializers.ListField(
        child=serializers.CharField(max_length=20),
        required=False,
        default=[]
    )
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'content', 'tags']

这样我们可以处理如下的文章数据：

json复制{
    "id": 1,
    "title": "DRF高级技巧",
    "content": "...",
    "tags": ["django", "rest", "api"]
}

3.3 高级配置选项

ListField提供了丰富的配置参数：

• child：指定列表元素的字段类型（必须）
• min_length：最小长度限制
• max_length：最大长度限制
• allow_empty：是否允许空列表（默认True）
• required：是否为必填字段（默认True）
• default：默认值

一个更严格的例子：

python复制scores = serializers.ListField(
    child=serializers.FloatField(min_value=0, max_value=100),
    min_length=3,
    max_length=3,
    allow_empty=False,
    required=True
)

3.4 嵌套数据结构

ListField和DictField可以组合使用，处理更复杂的嵌套结构：

python复制survey_answers = serializers.ListField(
    child=serializers.DictField(
        child=serializers.CharField(),
        allow_empty=False
    ),
    min_length=1
)

可以处理如下的问卷回答数据：

json复制[
    {
        "question_id": 1,
        "answer": "满意"
    },
    {
        "question_id": 2,
        "answer": "每周2-3次"
    }
]

4. 自定义字段的高级技巧

4.1 为什么需要自定义字段

虽然DRF提供了丰富的内置字段类型，但实际开发中我们经常遇到需要特殊处理的场景：

• 特殊的数据格式（如手机号、身份证号）
• 复杂的数据验证逻辑
• 需要转换数据格式
• 需要访问请求上下文

4.2 自定义字段的基本结构

创建一个自定义字段需要继承serializers.Field类并实现两个方法：

python复制from rest_framework import serializers

class CustomField(serializers.Field):
    def to_representation(self, value):
        """将Python对象转换为可序列化的基本数据类型"""
        # 实现转换逻辑
        return transformed_value
    
    def to_internal_value(self, data):
        """将基本数据类型转换为Python对象"""
        # 实现验证和转换逻辑
        return validated_value

4.3 实际案例：手机号字段

让我们实现一个手机号字段：

python复制import re
from rest_framework import serializers

class PhoneNumberField(serializers.Field):
    def to_representation(self, value):
        # 存储时可能是字符串，直接返回
        return value
    
    def to_internal_value(self, data):
        # 验证手机号格式
        if not re.match(r'^1[3-9]\d{9}$', data):
            raise serializers.ValidationError("手机号格式不正确")
        return data

使用方式：

python复制class UserSerializer(serializers.ModelSerializer):
    phone = PhoneNumberField()
    
    class Meta:
        model = User
        fields = ['id', 'name', 'phone']

4.4 实际案例：JSON字符串字段

有时我们需要处理存储在数据库中的JSON字符串：

python复制import json
from rest_framework import serializers

class JSONStringField(serializers.Field):
    def to_representation(self, value):
        # 数据库中的JSON字符串 -> Python对象
        try:
            return json.loads(value)
        except json.JSONDecodeError:
            return {}
    
    def to_internal_value(self, data):
        # Python对象 -> JSON字符串
        if isinstance(data, str):
            try:
                json.loads(data)  # 验证字符串是否为合法JSON
                return data
            except json.JSONDecodeError:
                pass
        return json.dumps(data)

4.5 自定义字段的高级用法

4.5.1 访问请求上下文

有时我们需要在字段中访问请求对象：

python复制class CurrentUserDefault:
    def set_context(self, serializer_field):
        self.user = serializer_field.context['request'].user
    
    def __call__(self):
        return self.user

class PostSerializer(serializers.ModelSerializer):
    author = serializers.HiddenField(
        default=CurrentUserDefault()
    )

4.5.2 复合字段

我们可以创建组合多个验证逻辑的复合字段：

python复制class ComboField(serializers.Field):
    def __init__(self, **kwargs):
        self.fields = [
            serializers.CharField(max_length=100),
            serializers.EmailField(),
            serializers.URLField()
        ]
        super().__init__(**kwargs)
    
    def to_internal_value(self, data):
        errors = []
        for field in self.fields:
            try:
                return field.to_internal_value(data)
            except serializers.ValidationError as e:
                errors.append(e.detail)
        raise serializers.ValidationError(errors)
    
    def to_representation(self, value):
        return value

5. 性能优化与最佳实践

5.1 DictField/ListField的性能考量

虽然DictField和ListField很方便，但在处理大量数据时需要注意：

1. 验证开销：每个元素都会经过完整的验证流程
2. 内存占用：大列表/字典会消耗较多内存
3. 数据库查询：嵌套结构可能导致N+1查询问题

优化建议：

• 对于大型数据集，考虑使用分页
• 使用select_related和prefetch_related优化关联查询
• 对只读字段使用SerializerMethodField减少验证开销

5.2 字段选择的黄金法则

1. 简单结构优先：能用简单字段就不用复杂字段
2. 固定结构用Serializer：如果数据结构固定且有明确字段，使用嵌套Serializer
3. 动态结构用DictField/ListField：只有真正需要处理动态结构时才使用它们
4. 自定义字段要谨慎：确保没有内置字段能满足需求再考虑自定义

5.3 常见陷阱与解决方案

5.3.1 缺失字段处理

当DictField的某些键可能不存在时：

python复制# 不好的做法
data = serializer.validated_data['config'].get('key', default)

# 更好的做法
class MySerializer(serializers.Serializer):
    config = serializers.DictField(
        child=serializers.CharField(),
        default=dict
    )
    key = serializers.SerializerMethodField()
    
    def get_key(self, obj):
        return obj['config'].get('key', 'default')

5.3.2 嵌套验证问题

嵌套的DictField/ListField验证错误信息可能难以理解：

python复制# 解决方案：自定义错误消息
class NestedSerializer(serializers.Serializer):
    items = serializers.ListField(
        child=serializers.DictField(
            child=serializers.IntegerField(),
            error_messages={
                'invalid': "必须是一个键值对对象",
                'null': "不能为null"
            }
        ),
        error_messages={
            'invalid': "必须是一个列表",
            'empty': "列表不能为空"
        }
    )

5.3.3 数据库兼容性

不是所有数据库都原生支持JSON字段（特别是旧版本）：

python复制# 解决方案：使用TextField+JSONStringField组合
class Product(models.Model):
    specs = models.TextField()  # 存储JSON字符串

class ProductSerializer(serializers.ModelSerializer):
    specs = JSONStringField()
    
    class Meta:
        model = Product
        fields = '__all__'

6. 实战：构建一个完整的API端点

让我们把这些知识应用到一个实际例子中：构建一个任务管理系统API。

6.1 模型定义

python复制from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    completed = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    tags = models.JSONField(default=list)  # 存储标签列表
    metadata = models.JSONField(default=dict)  # 存储额外元数据

6.2 序列化器实现

python复制from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    tags = serializers.ListField(
        child=serializers.CharField(max_length=20),
        required=False,
        default=[]
    )
    metadata = serializers.DictField(
        child=serializers.CharField(),
        required=False,
        default={}
    )
    
    class Meta:
        model = Task
        fields = ['id', 'title', 'description', 'completed', 
                 'created_at', 'updated_at', 'tags', 'metadata']
    
    def validate_metadata(self, value):
        # 自定义验证逻辑
        if 'priority' in value and value['priority'] not in ['low', 'medium', 'high']:
            raise serializers.ValidationError("优先级必须是low/medium/high")
        return value

6.3 视图集配置

python复制from rest_framework import viewsets
from .models import Task
from .serializers import TaskSerializer

class TaskViewSet(viewsets.ModelViewSet):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer
    
    def get_queryset(self):
        queryset = super().get_queryset()
        # 根据metadata中的priority过滤
        priority = self.request.query_params.get('priority')
        if priority:
            queryset = queryset.filter(metadata__priority=priority)
        return queryset

6.4 测试API

创建任务：

bash复制curl -X POST \
  http://localhost:8000/api/tasks/ \
  -H 'Content-Type: application/json' \
  -d '{
    "title": "完成DRF项目",
    "description": "实现DictField和ListField功能",
    "tags": ["django", "drf", "api"],
    "metadata": {
        "priority": "high",
        "due_date": "2023-12-31"
    }
}'

获取任务列表：

bash复制curl http://localhost:8000/api/tasks/?priority=high

7. 调试技巧与常见问题排查

7.1 调试序列化过程

当DictField/ListField出现问题时，可以这样调试：

1. 检查输入数据：确保传入的数据格式正确
2. 打印中间结果：在自定义字段的to_internal_value/to_representation中添加print语句
3. 使用DRF的Browsable API：可视化查看错误信息

7.2 常见错误与解决方案

错误1：Expected a list of items but got type "dict"

原因：向ListField传递了字典而不是列表
解决方案：检查数据格式，确保传递的是数组

错误2：{...} is not a valid value for a DictField

原因：DictField的child字段验证失败
解决方案：检查字典中的所有值是否符合child字段类型要求

错误3：This field is required

原因：required=True的字段没有提供值
解决方案：要么提供值，要么设置required=False

7.3 性能监控

使用Django Debug Toolbar监控序列化性能：

1. 安装调试工具栏：

bash复制pip install django-debug-toolbar

2. 配置settings.py：

python复制INSTALLED_APPS += ['debug_toolbar']
MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']
INTERNAL_IPS = ['127.0.0.1']

3. 检查SQL查询和缓存使用情况，优化N+1查询问题

8. 进阶：自定义字段的高级模式

8.1 动态字段类型

有时候我们需要根据输入数据动态决定字段类型：

python复制class DynamicField(serializers.Field):
    def to_internal_value(self, data):
        if isinstance(data, list):
            return serializers.ListField(child=serializers.CharField()).to_internal_value(data)
        elif isinstance(data, dict):
            return serializers.DictField(child=serializers.CharField()).to_internal_value(data)
        return data
    
    def to_representation(self, value):
        return value

8.2 字段级权限控制

可以在字段中实现细粒度的权限控制：

python复制class RestrictedField(serializers.Field):
    def __init__(self, **kwargs):
        self.permission = kwargs.pop('permission', None)
        super().__init__(**kwargs)
    
    def to_representation(self, value):
        request = self.context.get('request')
        if self.permission and not request.user.has_perm(self.permission):
            return None
        return value

使用方式：

python复制class SecretDocumentSerializer(serializers.ModelSerializer):
    content = RestrictedField(permission='documents.view_secret')

8.3 字段版本控制

实现支持多版本API的字段：

python复制class VersionedField(serializers.Field):
    def __init__(self, **kwargs):
        self.versions = kwargs.pop('versions', {})
        super().__init__(**kwargs)
    
    def to_representation(self, value):
        request = self.context.get('request')
        version = request.version if hasattr(request, 'version') else 'v1'
        transform = self.versions.get(version, lambda x: x)
        return transform(value)

使用方式：

python复制class UserSerializer(serializers.ModelSerializer):
    name = VersionedField(versions={
        'v1': lambda x: x,
        'v2': lambda x: x.upper()
    })

9. 测试策略与覆盖率

9.1 单元测试自定义字段

为自定义字段编写全面的测试：

python复制from django.test import TestCase
from rest_framework.exceptions import ValidationError
from .fields import PhoneNumberField

class PhoneNumberFieldTest(TestCase):
    def setUp(self):
        self.field = PhoneNumberField()
    
    def test_valid_phone(self):
        self.assertEqual(self.field.to_internal_value('13800138000'), '13800138000')
    
    def test_invalid_phone(self):
        with self.assertRaises(ValidationError):
            self.field.to_internal_value('123456')
    
    def test_international_phone(self):
        with self.assertRaises(ValidationError):
            self.field.to_internal_value('+8613800138000')

9.2 序列化器集成测试

测试整个序列化器的行为：

python复制class TaskSerializerTest(TestCase):
    def test_valid_data(self):
        data = {
            'title': 'Test',
            'description': 'Test description',
            'tags': ['urgent', 'important'],
            'metadata': {'priority': 'high'}
        }
        serializer = TaskSerializer(data=data)
        self.assertTrue(serializer.is_valid())
    
    def test_invalid_metadata(self):
        data = {
            'title': 'Test',
            'description': 'Test description',
            'metadata': {'priority': 'invalid'}
        }
        serializer = TaskSerializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertIn('metadata', serializer.errors)

9.3 性能测试

使用django.test.utils.setup_test_environment测试序列化性能：

python复制from django.test.utils import setup_test_environment
import time
from .serializers import LargeDataSetSerializer

class SerializerPerformanceTest(TestCase):
    @classmethod
    def setUpClass(cls):
        setup_test_environment()
        cls.data = {'items': [{'id': i, 'value': str(i)} for i in range(1000)]}
    
    def test_serialization_speed(self):
        start = time.time()
        serializer = LargeDataSetSerializer(data=self.data)
        serializer.is_valid()
        end = time.time()
        self.assertLess(end - start, 0.1)  # 确保在100ms内完成

10. 与其他DRF功能的集成

10.1 与分页集成

处理包含DictField/ListField的分页结果：

python复制from rest_framework.pagination import PageNumberPagination
from rest_framework.response import Response

class CustomPagination(PageNumberPagination):
    def get_paginated_response(self, data):
        return Response({
            'links': {
                'next': self.get_next_link(),
                'previous': self.get_previous_link()
            },
            'count': self.page.paginator.count,
            'results': data,
            'metadata': {
                'page_size': self.page_size,
                'current_page': self.page.number
            }
        })

10.2 与过滤器集成

实现基于DictField内容的过滤：

python复制from django_filters import rest_framework as filters
from .models import Task

class TaskFilter(filters.FilterSet):
    has_priority = filters.BooleanFilter(
        field_name='metadata__priority',
        lookup_expr='isnull',
        exclude=True
    )
    
    class Meta:
        model = Task
        fields = {
            'metadata__priority': ['exact'],
            'tags': ['contains']
        }

10.3 与权限控制集成

结合字段级权限和视图级权限：

python复制from rest_framework.permissions import BasePermission

class MetadataPermission(BasePermission):
    def has_permission(self, request, view):
        return request.user.has_perm('tasks.view_metadata')
    
    def has_object_permission(self, request, view, obj):
        return self.has_permission(request, view)

class TaskViewSet(viewsets.ModelViewSet):
    # ...
    def get_serializer_context(self):
        context = super().get_serializer_context()
        context['has_metadata_permission'] = self.request.user.has_perm('tasks.view_metadata')
        return context

然后在序列化器中：

python复制class TaskSerializer(serializers.ModelSerializer):
    # ...
    def to_representation(self, instance):
        data = super().to_representation(instance)
        if not self.context.get('has_metadata_permission'):
            data.pop('metadata', None)
        return data

11. 生产环境最佳实践

11.1 安全性考虑

1. 防止过度暴露：谨慎选择包含在DictField/ListField中的敏感数据
2. 输入验证：对所有用户输入进行严格验证，特别是嵌套数据
3. 大小限制：为大型Dict/List设置合理的大小限制

python复制class SafeDictField(serializers.DictField):
    def __init__(self, **kwargs):
        kwargs.setdefault('max_length', 100)  # 限制键值对数量
        super().__init__(**kwargs)
    
    def to_internal_value(self, data):
        data = super().to_internal_value(data)
        # 过滤掉敏感键
        return {k: v for k, v in data.items() if not k.startswith('_')}

11.2 性能优化

1. 缓存序列化结果：对于不常变化的数据
2. 选择性字段：使用fields参数动态控制返回字段
3. 批量操作：优化批量创建/更新操作

python复制class BulkTaskSerializer(serializers.ListSerializer):
    def create(self, validated_data):
        tasks = [Task(**item) for item in validated_data]
        return Task.objects.bulk_create(tasks)

class TaskSerializer(serializers.ModelSerializer):
    # ...
    class Meta:
        list_serializer_class = BulkTaskSerializer

11.3 监控与日志

记录DictField/ListField的异常：

python复制class LoggingDictField(serializers.DictField):
    def to_internal_value(self, data):
        try:
            return super().to_internal_value(data)
        except Exception as e:
            logger.error(f"DictField validation failed: {e}", 
                        extra={'data': str(data)[:100]})
            raise

12. 未来演进与替代方案

12.1 DRF的未来发展方向

根据DRF的演进路线，DictField和ListField可能会：

1. 支持更强大的模式验证（如JSON Schema）
2. 提供更好的性能优化选项
3. 增强与GraphQL的集成

12.2 替代方案比较

1. 嵌套Serializer：

   • 适合固定结构
   • 提供更严格的验证
   • 代码更冗长

2. JSONField（Django 3.1+）：

   • 直接使用PostgreSQL的JSON字段
   • 更简单的查询语法
   • 需要数据库支持

3. 第三方包（如drf-extra-fields）：

   • 提供更多现成的字段类型
   • 增加依赖项
   • 可能更新不及时

12.3 迁移策略

从DictField/ListField迁移到其他方案的建议：

1. 评估数据结构稳定性：如果结构变得固定，考虑迁移到嵌套Serializer
2. 性能分析：使用django-debug-toolbar识别性能瓶颈
3. 渐进式迁移：可以同时支持新旧格式一段时间

python复制class TransitionalSerializer(serializers.ModelSerializer):
    old_format = serializers.DictField(required=False)
    new_field1 = serializers.CharField(required=False)
    new_field2 = serializers.IntegerField(required=False)
    
    def to_representation(self, instance):
        data = super().to_representation(instance)
        if 'old_format' in data:
            data.update(data.pop('old_format'))
        return data
    
    def to_internal_value(self, data):
        if 'new_field1' not in data:  # 旧格式
            return {'old_format': data}
        return data

13. 真实项目经验分享

在实际项目中使用DictField和ListField时，我总结了一些宝贵经验：

1. 版本兼容性：在API响应中添加版本信息，特别是当DictField的结构可能变化时

python复制class ProductSerializer(serializers.ModelSerializer):
    version = serializers.SerializerMethodField()
    
    def get_version(self, obj):
        return '1.1' if 'new_field' in obj.metadata else '1.0'

2. 文档生成：为动态字段添加清晰的文档说明

python复制class ProductSerializer(serializers.ModelSerializer):
    attributes = serializers.DictField(
        child=serializers.CharField(),
        help_text="""
        产品动态属性，格式为键值对。
        常用键包括: color, size, weight
        """
    )

3. 团队协作：建立DictField键名的命名规范，避免混乱

4. 性能监控：特别关注大型列表/字典的序列化性能

python复制# 在中间件中监控序列化时间
class SerializationMetricsMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    
    def __call__(self, request):
        start = time.time()
        response = self.get_response(request)
        duration = time.time() - start
        if duration > 0.5:  # 超过500ms记录警告
            logger.warning(f"Long serialization: {duration:.3f}s for {request.path}")
        return response

5. 测试策略：为动态字段编写更全面的测试用例

python复制class DictFieldTests(TestCase):
    @parameterized.expand([
        ({'valid': 'data'}, True),
        ({'invalid': 123}, False),  # 值应该是字符串
        ('not-a-dict', False),
        (None, False),
    ])
    def test_dict_field_validation(self, input, expected_valid):
        serializer = TestSerializer(data={'data': input})
        self.assertEqual(serializer.is_valid(), expected_valid)

14. 总结与个人实践心得

经过多个项目的实践，我认为DictField和ListField是DRF中最被低估的功能之一。它们为处理动态数据结构提供了极大的灵活性，但也需要谨慎使用。

几个关键体会：

1. 明确边界：在项目早期就明确哪些数据适合用动态字段，哪些应该用固定结构。我通常会为每个DictField定义一组"建议键名"，即使不强制要求。

2. 文档至上：动态字段更需要详细文档。我们团队的做法是为每个DictField添加一个_schema示例：

python复制metadata = serializers.DictField(
    help_text="""
    元数据字段，示例:
    {
        "_schema": "v1",
        "priority": "high|medium|low",
        "due_date": "YYYY-MM-DD"
    }
    """
)

3. 性能意识：在处理大型数据集时，我们建立了一个规则：任何返回超过100个元素的ListField都必须支持分页。

4. 渐进增强：从严格验证开始，随着需求明确再逐步放宽限制。比一开始宽松后来收紧要容易得多。

5. 监控报警：我们对序列化错误率设置了监控，特别是对动态字段的验证错误。

一个特别有用的模式是创建"严格模式"和"宽松模式"的字段变体：

python复制class StrictDictField(serializers.DictField):
    def __init__(self, **kwargs):
        kwargs.setdefault('allow_empty', False)
        kwargs.setdefault('required', True)
        super().__init__(**kwargs)

class LooseDictField(serializers.DictField):
    def __init__(self, **kwargs):
        kwargs.setdefault('allow_empty', True)
        kwargs.setdefault('required', False)
        kwargs.setdefault('default', dict)
        super().__init__(**kwargs)

这样在代码中可以根据不同场景选择合适的严格级别。