Django 如何从子序列化程序获取特定字段？

比如说，有两种模式：

class Model1(models.Model):
    r = models.CharField(max_length=200)

class Model2(models.Model):
    p = models.CharField(max_length=200)
    m = models.ForeignKey(Model1,on_delete=models.CASCADE)

序列化程序包括：

class Model1Serializer(serializers.Serializer):
    class Meta:
        model = Model1
        fields = '__all__'

class Model2Serializer(serializers.Serializer):
    class Meta:
         model = Model2
         fields = '__all__'

给定的Model1序列化程序将输出返回为： { “id”：1， “r”：“r_值” }

模型2序列化程序输出为： { “id”：1， “p:“p_值”， “m”：1 }

---

问题是，我还需要model2序列化程序输出中的r值。如何做到这一点？

您需要使用正确的

源指定新字段-您可以在中阅读更多内容

选项1：使用类序列化程序：
输出：
{'p'：u'pppp'，'r'：u'rrrrr'，'id'：1}

选项2：使用类ModelSerializer：
输出：
{'p'：u'pppp'，r'：u'rrrrr'，m'：1L，u'id'：1}

选项3：包括整个模型1：
输出：
{'m'：OrderedDict（[（u'id'，1），（'r'，u'rrrrr'））}
如果您已经有了Model1的
Model1Serializer
：

class Model2Serializer(serializers.Serializer):
    m = Model1Serializer()
    class Meta:
         model = Model2
         fields = '__all__'

应该是这样。
1.如果你想让r作为m的属性
定义特定关系字段的序列化程序类


类Model2Serializer（serializers.ModelSerializer）：
m=Model1Serializer（）
类元：
模型=模型2
字段='\uuuu所有\uuuu'

输出：


[
    {
        "id": 1,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Light RED"
    },
    {
        "id": 2,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Dark RED"
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

2.如果您只想使用ReadOnlyField
您可以使用ReadOnlyField


类Model2Serializer（serializers.ModelSerializer）：
r=序列化程序。只读字段（source='m.r'）
类元：
模型=模型2
字段='\uuuu所有\uuuu'

输出：


[
    {
        "id": 1,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Light RED"
    },
    {
        "id": 2,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Dark RED"
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

3.如果您只需要使用SerializerMethodField（）的序列化器
您还可以序列化MethodField并将其设置为只读


类Model2Serializer（serializers.ModelSerializer）：
r=序列化程序。SerializerMethodField（）
类元：
模型=模型2
字段='\uuuu所有\uuuu'
def get_r（自身，实例）：
返回实例.m.r

输出：


[
    {
        "id": 1,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Light RED"
    },
    {
        "id": 2,
        "m": {
            "id": 1,
            "r": "RED"
        },
        "p": "Dark RED"
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

[
    {
        "id": 1,
        "r": "RED",
        "p": "Light RED",
        "m": 1
    },
    {
        "id": 2,
        "r": "RED",
        "p": "Dark RED",
        "m": 1
    }
]

试试这个

class Model1Serializer(serializers.Serializer):
   class Meta:
      model = Model1
      fields = '__all__'

class Model2Serializer(serializers.Serializer):
  r = Model1Serializer(many=True, source="model1_set")
  class Meta:
     model = Model2
     fields = '__all__'

只需在序列化程序元中使用
depth=1
。如下所示：

class Model2Serializer(serializers.Serializer):
    class Meta:
         model = Model2
         fields = '__all__'
         depth = 1

这将使该型号中存在的外键达到1级。（顺便说一句，我不建议大型型号使用它。但它非常适合您的情况）
请将正确答案标记为已接受。