Python 德扬戈。未正确删除记录

我有个问题，希望你能帮我

我得到了这些模型：

MODELS = (
('A', 'A'),
('B', 'B'),
)


class person(models.Model):
    nombre = models.CharField(max_length=128)
    model = models.CharField(max_length=128,choices=MODELS, default=True)

    def __str__(self):
        return self.nombre


class person_A(models.Model):
    person = models.ForeignKey(person, on_delete=models.PROTECT, null=True)
    hobbies = models.CharField(max_length=40, default='')

    def __str__(self):
        return self.person.nombre

class person_B(models.Model):
    person = models.ForeignKey(person, on_delete=models.PROTECT, null=True)
    age = models.IntegerField(default=10)

    def __str__(self):
        return self.person.nombre

如您所见，我有

个人A

，

个人B

，它们将保存在我的数据库中

以下是我的看法：

def get_person(request):
    titulo = 'Person'
    qs_a = person_A.objects.all()
    qs_b = person_B.objects.all()
    qs = chain(qs_b,qs_a)
    form = person_aForm(request.POST or None)
    form2 = personForm(request.POST or None)
    form4 = person_bForm(request.POST or None)
    context = {
        "qs_a": qs_a,
        "qs_b": qs_b,
        "qs": qs,
        "form2": form2,
        "form": form,
        "form4": form4,
        "titulo": titulo,
    }
    form2_valid = form2.is_valid()
    form_valid = form.is_valid()
    form4_valid = form4.is_valid()
    if form2_valid:
        person = form2.save()
        if form_valid:
            person_a = form.save(commit=False)
            person_a.person = person
            person_a.save()
            messages.success(request, 'Se ha guardado satisfactoriamente')
            return redirect("get_person")
        if form4_valid:
            person_b = form4.save(commit=False)
            person_b.person = person
            person_b.save()
            messages.success(request, 'Se ha guardado satisfactoriamente')
            return redirect("get_person")
    return render(request, "person.html", context)

如您所见，这里正在为

个人A

或

个人B

保存我的表单

以下是我的删除功能：

def delete_person(request,id):
    try:
        qs = person_B.objects.all()
        instance = get_object_or_404(qs, id=id)
        instance.delete()
        messages.success(request, 'B')
    except:
        try: 
            qs = person_A.objects.all()
            instance = get_object_or_404(qs, id=id)
            instance.delete()
            messages.success(request, 'A')
        except:
            pass
    return redirect('get_person')

我的网址：

url(r'^delete_person/(?P<id>\d+)/$',views.delete_person, name='delete_person'),

url（r'^delete\u person/（？P\d+/$），views.delete\u person，name='delete\u person'），

模板：

<table class="table table-hover">
    <thead>
      <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Last Name</th>
        <th>Delete</th>
      </tr>
    </thead>
    <tbody>
    {% for item in qs  %}
      <tr>
        <td>{{ item.id }}</td>
        <td>{{ item.person.model }}</td>
        <td>{{ item.person.nombre }}</td>
        <td><a href="{% url 'delete_person' item.id %}">Delete</a></td>
      </tr>
    {% endfor %}
    </tbody>
</table>

身份证件
名称
姓
删除
{qs%中项目的%s}
{{item.id}
{{item.person.model}
{{item.person.nombre}
{%endfor%}

基本上，我有两个不同的模型，每个人都保存在数据库中，并显示在

表中。为此，我使用了
itertools
中的
chain（）。我将人员A和人员B合并在一个
表中显示它们。这很好，现在我的问题是：

如果
person\u A
具有与
person\u B
相同的
id
，并且我想删除
person\u A
，它将删除
person\u B
。我知道这是由于
chain（）
造成的，但我想知道是否有可能的方法来解决这个问题

谢谢
您的问题在于
删除函数（）
总是先尝试删除
个人。除非抛出异常，
person\u A
将永远不会被删除。如果抛出异常，您仍将首先删除
人员_B
，因为它位于
try:
块中，因此尝试删除它总是在尝试删除
人员_A
之前。顺便说一句，按照现在编写代码的方式，任何异常都会导致尝试删除
person\u A
。我建议使用更具体的异常，否则以后可能会遇到真正令人困惑的bug

至于解决方案，我相信还有更聪明的方法，但我现在可以想到几个快速而肮脏的解决方案：

定义一个自定义项，该自定义项将检查
person
是什么类型的类，并相应地执行操作（例如，为不同的类调用不同的delete方法；将标志作为传递并在
delete\u person（）
方法中使用，以确定要删除的
person
）
我可能会做的是：不要链接模型的实例，而是单独迭代它们，并调用适合特定模型的delete方法：

 <table>
 <thead>...</thead>
 <tbody>
   ...
   {% for item in qs_a %}
     <tr>
       <td>... delete_person_A() ...</td>
     </tr>
   {% endfor %}
   {% for item in qs_b %}
     <tr>
       <td>... delete_person_B() ...</td>
     </tr>
   {% endfor %}
 </tbody>
 </table>


...
...
{qs_a%中项目的%s}
... 删除\u person\u A（）。。。
{%endfor%}
{qs_b%中项目的%s}
... 删除\u person\u B（）。。。
{%endfor%}

如果我没有记错的话，
chain（）
在第一个iterable上迭代，直到它用完为止，然后才在第二个iterable上迭代。因此，分别迭代
qs_a
和
qs_b
不会对输出产生很大影响。虽然这样您将不得不编写更多的代码，但它也将更加简单和明确——因此，如果需要的话，以后更容易理解和重构

谢谢你，先生，你的回答帮了我一把。到目前为止，我使用了你的第二种方法，我认为这是最简单的一种，而且迄今为止效果很好。