django中的继承有三类;
- 1.抽象继承
- 2.多表继承
- 3.proxy model（代理模型）
第一种情况
第1种情况表示你的父类仅仅是包含了多个子类的相同的字段，是为了重用，不会建表，我们只需要在抽象父类的Meta中设置abstract=True就行。比如：
class CommonInfo(models.Model):
name = models.CharField(max_length=100)
age = models.PositiveIntegerField()
class Meta:
abstract = True
class Student(CommonInfo):
home_group = models.CharField(max_length=5)
这个时候，父类Meta中的abstract=True是不会传递给子类的，django会将子类的abstract设置为False
除了abstract之外，父类Meta中的db_table也不会继承给子类
在抽象类中使用关系（如外键，多对多关系，一对一关系）时候，肯定会设置related_name，但是子类继承抽象父类的时候，由于父类中的字段会继承给子类，则具有related_name的字段会被多个子类共享的。这样每一个子类的related_name就都一样了，其他模型通过related_name就不能找到正确的子类。
所以要正确设置related_name，related_name中必须包含%(app_label)s 和 %(class)s。如
%(app_label)s表示小写形式的，当前模型所在的，并且已经安装的app的名字%(class)s表示小写形式的，当前子类的类名字。
在common/models.py，有
class Base(models.Model):
m2m = models.ManyToManyField(OtherModel, related_name="%(app_label)s_%(class)s_related")
class Meta:
abstract = True
class ChildA(Base):
pass
class ChildB(Base):
pass
在rare/models.py，有
from common.models import Base
class ChildB(Base):
pass
所以，上面的related_name就是 common_childa_related和 common_childb_related
第二种情况
第2中是多表继承，其中父类也是一个django模型，并且也会创建一个数据表，多表继承是django中隐式的一对一关系。例如:
class Place(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_length=80)
class Restaurant(Place):
serves_hot_dogs = models.BooleanField()
serves_pizza = models.BooleanField()
其中虽然name和address存储在模型Place的表中，但是name和address对于Restaurant也是有效字段
>>> Place.objects.filter(name="Bob's Cafe")
>>> Restaurant.objects.filter(name="Bob's Cafe")
Restaurant和Place的关系，可以这么说：一个Restaurant一定是一个Place，而一个Place不一定是Restaurant
多表继承中，一般，父类的Meta属性不会继承到子类中，但是，ordering和 get_latest_by是继承的，如果子类不想继承父类的ordering的Meta，则可以手动显式的指定ordering=[]或者任何自己想要的值
多表继承的时候，是隐式的在父类和子类之间建立一个一对一关系，所以有时候，父类与其他类的关系会从父类下移到子类中。如果有多个子类，且子类不在关系中显式地指定related_name字段，django会引发验证错误
class Supplier(Place):
# Must specify related_name on all relations.
customers = models.ManyToManyField(Restaurant, related_name='provider')
所以，继承父类，一旦子类中有关系，就加上related_name吧
django自动在子类和非抽象父类之间创建一个一对一关系，如果你想控制由子类连接回父类的属性的名字，你可以创建一个一对一关系，然后设置parent_link=True
class BaseOrder(models.Model):
pass
class Gap(BaseOrder):
baseorder = models.OneToOneField(BaseOrder, parent_link=True)
第三代理模型
在多表继承中，子类模型会创建一个数据表来存储不在父类模型中的额外字段，但是，如果我们只想改变某个模型的行为方法，而不是添加额外的字段，我们就可以使用
proxy model。代理model（proxy model）会继承父类的属性，并且只是添加一些对属性的操作的自定义方法而已。
class MyPerson(Person):
class Meta:
proxy = True
def do_something(self):
...zh
这里，MyPerson没有多创建数据表，MyPerson也是对Person的数据表进行操作，一般的，我们可以把MyPerson当做Person来使用，只是在do_something这个方法略有不同，比如
>>> p = Person.objects.create(first_name="foobar")
>>> MyPerson.objects.get(first_name="foobar")
<MyPerson: foobar>
代理模型和原模型的区别如下面：
class OrderedPerson(Person):
class Meta:
ordering = ["last_name"]
proxy = True
这里，OrderedPerson并不是创建了一个表，而是代理排序方法。也就是说，使用Person的检索方法并不会按last_name排序，而使用OrderedPerson检索出来的结果是按last_name排序的。OrderedPerson使用与Person类一样的检索方法。
OrderPerson返回的queryset自然是Person的，这是当然的。我们不能要求django返回OrderedPerson类的queryset，因为OrderedPerson只是代理而已，又不是真实的数据库表类。
注意的是，proxy model不能继承于抽象类，这是因为代理model是操作连接数据库的，也不能多重继承~因为你多重继承了，代理model就不知道去哪个父类找属性了
如果不指定代理model的manage，则代理model会自动继承父类的manage。我们也可以手动设置代理model的manage，这样，代理模型和父类模型的manage就分开了
为代理模型添加manage有两种方法：
一是直接在代理模型中直接指定manage
class NewManager(models.Manager):
...
class MyPerson(Person):
objects = NewManager()
class Meta:
proxy = True
另外一种是当你不想覆盖父类模型中的manage但又想添加额外的manage，我们可以新建一个抽象模型，然后定义其manage，之后继承该抽象模型，如：
# Create an abstract class for the new manager.
class ExtraManagers(models.Model):
secondary = NewManager()
class Meta:
abstract = True
class MyPerson(Person, ExtraManagers):
class Meta:
proxy = True
摘自这里
