Django 2.1.3 模型层 模型

本章完…

---

模型是您的数据唯一而且准确的信息来源。它包含您正在储存的数据的重要字段和行为。一般来说，每一个模型都映射一个数据库表。

基础：

• 每个模型都是一个 Python 的类，这些类继承 django.db.models.Model
• 模型类的每个属性都相当于一个数据库的字段。
• 综上所说，Django 给你一个自动生成访问数据库的 API；请参阅 执行查询。

1. 快速上手

这个样例模型定义了一个 Person类, 其拥有 first_name 和 last_name属性:

first_name 和 last_name 是 模型的字段。每个字段都被指定为一个类属性，并且每个属性映射为一个数据库列。
上面的 Person 模型会创建一个如下的数据库表：

一些技术上的说明：

• 该表的名称 “myapp_person” 是自动从某些模型元数据中派生出来，但可以被改写。有关更多详细信息，请参阅：表名。
• 一个 id 字段会被自动添加，但是这种行为可以被改写。请参阅：默认主键字段。
• 此例中的建表语句使用了PostgreSQL语法，但是值得注意的是Django使用的SQL语句跟你在配置文件中指定的数据库有关。

---

2. 使用模型

一旦你定义了你的模型，你需要告诉 Django 你准备使用这些模型。你需要修改设置文件中的 INSTALLED_APPS ，在这个设置中添加包含 models.py文件的模块的名字。

例如，如果模型位于你项目中的myapp.models中（ 此包结构使用:python manage.py startapp命令创建），NSTALLED_APPS 应设置如下:

当你在INSTALLED_APPS配置新的app后,请记住按顺序执行manage.py makemigrations和manage.py migrate这两条命令。

---

3. 字段

模型中最重要的、并且也是唯一需要指定的应用于数据库的字段定义。字段在类中定义。定义字段名时应小心避免使用与 models API 冲突的名称， 如 clean，save，delete等。

举例：

from django.db import models

class Musician(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    instrument = models.CharField(max_length=100)

class Album(models.Model):
    artist = models.ForeignKey(Musician, on_delete=models.CASCADE)
    name = models.CharField(max_length=100)
    release_date = models.DateField()
    num_stars = models.IntegerField()

3.1 字段类型

模型中每一个字段都应该是相应类的实例， Django 利用这些字段类来实现下面这些功能。

• 字段类型用以指定数据库数据类型（如：INTEGER, VARCHAR, TEXT）
• 默认的HTML widgets，用来渲染form中的子部件（如： ）
  用于Django admin和自动生成表单的基本验证。

  Django内置了多种字段类型；你可以在 模型字段参考中看到完整列表。如果Django内置类型不能满足你的需求，你可以很轻松地编写自定义的字段类型；见 自定义模型字段。

  3.2 字段选项

  每一种字段都需要指定一些特定的参数（参考 模型字段参考） 例如： CharField（以及它的子类）需要接收一个 max_length 参数，用以指定数据库存储数据时用的 VARCHAR 大小。

  一些可选的参数是通用的，可以用于任何字段类型，详情请见 指南，下面介绍一部分经常用到的通用参数：

  null
  如果设置为 True ， 当该字段为空时，Django会将数据库中该字段设置为 NULL 。默认为 False 。

  blank
  如果设置为 True ，该字段允许为空。默认为 False 。

  注意该选项与null不同， null 选项仅仅是数据库层面的设置，然而 blank 是涉及表单验证方面。如果一个字段设置为 blank=True ，在进行表单验证时，接收的数据该字段值允许为空，而设置为 blank=False 时，不允许为空。

  choices
  该参数接收一个可迭代的列表或元组（基本单位为二元组）。如果指定了该参数，在实例化该模型时，该字段只能取选项列表中的值。

  一个选项列表：

  YEAR_IN_SCHOOL_CHOICES = (
      ('FR', 'Freshman'),
      ('SO', 'Sophomore'),
      ('JR', 'Junior'),
      ('SR', 'Senior'),
      ('GR', 'Graduate'),
  )
  

  每个二元组的第一个值会储存在数据库中，而第二个值将只会用于显示作用。

  对于一个模型实例，要获取该字段二元组中相对应的第二个值，使用 get_FOO_display() 方法(FOO为字段名字）。例如：

  from django.db import models
  
  class Person(models.Model):
      SHIRT_SIZES = (
          ('S', 'Small'),
          ('M', 'Medium'),
          ('L', 'Large'),
      )
      name = models.CharField(max_length=60)
      shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)
  

  >>> p = Person(name="Fred Flintstone", shirt_size="L")
  >>> p.save()
  >>> p.shirt_size
  'L'
  >>> p.get_shirt_size_display()
  'Large'
  

  default
  该字段的默认值。可以是一个值或者是个可调用的对象，如果是个可调用对象，每次实例化模型时都会调用该对象。

  help_text
  针对某个表单部件的额外的提示信息。

  

  primary_key
  如果设置为 True ，将该字段设置为该模型的主键。

  在一个模型中，如果你没有对任何一个字段设置 primary_key=True选项。 Django 会自动添加一个 IntegerField 字段，用于设置为主键，因此除非你想重写 Django 默认的主键设置行为，你可以不手动设置主键。详情请见 自动设置主键 。

  主键字段是只可读的，如果你修改一个模型实例该字段的值并保存，你将等同于创建了一个新的模型实例。例如：

  from django.db import models
  
  class Fruit(models.Model):
      name = models.CharField(max_length=100, primary_key=True)
  

  >>> fruit = Fruit.objects.create(name='Apple')
  >>> fruit.name = 'Pear'
  >>> fruit.save()
  >>> Fruit.objects.values_list('name', flat=True)
  <QuerySet ['Apple', 'Pear']>
  

  unique
  如果设置为True,则该字段的值在整个表里面唯一。

  再次声明，以上只是一些通用参数的简略描述。你可以在 字段选项列表 中找到完整的介绍。

  3.3 自动设置主键

  默认情况下， Django 会给每一个模型添加下面的字段：
  
  这是一个自增的主键。

  如果你想指定某一字段为主键， 在该字段上设置primary_key=True 选项。如果 Django 看到你显式的设置了 Field.primary_key ，将不会自动在表（模型）中添加 id 列。

  每个模型都需要拥有一个设置了 primary_key=True 的字段（无论是显式的设置还是 Django 自动设置）。

  3.4 备注名

  （1）除了 ForeignKey ManyToManyField 和 OneToOneField ，任何字段类型都接收一个可选的参数 verbose_name 。

  如果未指定该参数值， Django 会自动使用该字段的属性名作为该参数值，并且把下划线转换为空格。

  在该例中 first_name属性的备注名为person's first name:

  first_name = models.CharField("person's first name", max_length=30)
  

  在该例中，备注名为first name:

  first_name = models.CharField(max_length=30)
  

  （2）
  ForeignKey, ManyToManyField 和 OneToOneField 接收的第一个参数为关联模型的类名，后面可以添加一个 verbose_name 参数：
  
  一般情况下不需要将 verbose_name 值首字母大写，必要时 Djanog 会自动把首字母转换为大写。

  3.5 关联关系

  显然，关系型数据库的强大之处在于各表之间的关联关系。 Django 提供了定义三种最常见的数据库关联关系的方法：多对一，多对多，一对一。

  3.5.1 多对一

  定义多对一的关联关系，使用 django.db.models.ForeignKey 类。就和其他 Field 字段类型一样，只需要在你模型中添加一个值为该类的属性。

  ForeignKey 需要一个必须的参数：和它关联的类的名字。

  例如，如果一个 Car 模型 有一个制造者 Manufacturer ，就是说一个 Manufacturer 制造许多辆车，但是每辆车都属于某个特定的制造者。那么使用下面的方法定义这个关系：

  from django.db import models
  
  class Manufacturer(models.Model):
      # ...
      pass
  
  class Car(models.Model):
      manufacturer = models.ForeignKey(Manufacturer, on_delete=models.CASCADE)
      # ...
  

  你也可以创建一个 递归关系（一个模型与它本身有多对一的关系[比如博客的父评论和子评论]）并且可以 对尚未定义的模型进行引用；详情请见 模型字段引用 。

  建议
  设置 ForeignKey 字段（上例中的 manufacturer ）名为想要关联的模型名，例如：

  class Car(models.Model):
      company_that_makes_it = models.ForeignKey(
          Manufacturer,
          on_delete=models.CASCADE,
      )
      # ...
  

  注意
  ForeignKey 字段还可以接收一些其他的参数，详见 模型字段引用 ，这些可选的参数可以更深入的规定关联关系的具体实现。
  有关反向查询（译者注：例如，一对多关系中，由一查多为反向查询，由多查一为正向查询），请见 反向查询。
  如要查看相关示例代码，详见 多对一关系实例 。↑

  3.5.2 多对多

  定义一个多对多的关联关系，使用 django.db.models.ManyToManyField 类。就和其他 Field 字段类型一样，只需要在你模型中添加一个值为该类的属性。

  ManyToManyField 类需要一个必须的参数：和它关联的类的名字。

  例如：如果 Pizza 含有多种 Topping（配料），也就是一种Topping 可能存在于多个 Pizza 中，并且每个 Pizza 含有多种 Topping。那么可以这样表示这种关系：

  from django.db import models
  
  class Topping(models.Model):
      # ...
      pass
  
  class Pizza(models.Model):
      # ...
      toppings = models.ManyToManyField(Topping)
  

  和 ForeignKey 类一样，你也可以创建 递归关系（一个对象与他本身有着多对多的关系）并且可以对尚未定义的模型进行引用。

  建议设置 ManyToManyField 字段（上例中的 toppings ）名为一个复数名词，表示所要关联的模型对象的集合。

  对于多对多关联关系的两个模型，可以在任何一个模型中添加 ManyToManyField 字段，但只能选择一个模型设置该字段，即不能同时在两模型中添加该字段。

  通常来讲，在表单中，一个ManyToManyField 属性应该跟随关联的对象出现。上面的例子中，通常我们会这样想，是Pizza中有toppings(多种配料)，而不是一种topping属于多个Pizzas。所以按照这种想法，在form表单中，应该是配料跟随Pizza对象出现。

  参见
  如要查看完整示例代码，详见 多对多关系实例。

  ManyToManyField字段还有另一些参数，这些 参数 用来定义多对多关系该如何执行，都是可选的。

  多对多关系中额外字段

  当您只处理简单的多对多关系时，例如比萨饼和配料，ManyToManyField就可以完成了 。但是，有时您可能需要将数据与两个模型之间的关系相关联。

  例如，考虑应用程序跟踪音乐家所属的音乐组的情况。一个人与他们所属的团体之间存在多对多的关系，因此您可以使用ManyToManyField来表示这种关系。但是，您可能希望收集成员的更多信息，例如此人加入该组的日期。

  对于这些情况，Django允许您指定将用于管理多对多关系的模型。然后，您可以在中间模型(多对多关系中的第三张表)上添加额外的字段。中间模型通过ManyToManyField使用through参数指向将充当中介的模型相关联 。对于我们的音乐家示例，代码看起来像这样：

  from django.db import models
  
  class Person(models.Model):
      name = models.CharField(max_length=128)
  
      def __str__(self):
          return self.name
  
  class Group(models.Model):
      name = models.CharField(max_length=128)
      members = models.ManyToManyField(Person, through='Membership')
  
      def __str__(self):
          return self.name
  
  class Membership(models.Model):
      person = models.ForeignKey(Person, on_delete=models.CASCADE)
      group = models.ForeignKey(Group, on_delete=models.CASCADE)
      date_joined = models.DateField()
      invite_reason = models.CharField(max_length=64)
  

  译者注:其实就是用户通过through关键字自定义多对多关系中的第三张表。

  设置中间模型时，您明确指定多对多关系中涉及的模型的外键。此声明显式定义了两个模型的关联方式。

  中间模型有一些限制：

  • 您的中间模型必须包含一个 且只有一个源模型的外键（在我们的示例中是Group），或者您必须通过 ManyToManyField.through_fields 属性显式指定Django应该用于该关系的外键。如果您有多个外键而且through_fields也没有指定，则会引发验证错误。类似的限制适用于另一个源模型外键（Person）。
  • 一个模型如果与自己有多对多关系，允许中间模型的有两个相同的源模型外键，但它们将被视为多对多关系的两个（不同）列。如果不止两个外键，你还必须指定through_fields属性如上所述，否则引发验证错误。
  • 在使用中间模型定义从模型到自身的多对多关系时，必须使用 symmetrical=False。
    假如，现在您已经设置了ManyToManyField使用中间模型（在本例中的Membership），您已准备好开始创建一些多对多关系。您可以通过创建中间模型的实例来完成此操作：

  >>> ringo = Person.objects.create(name="Ringo Starr")
  >>> paul = Person.objects.create(name="Paul McCartney")
  >>> beatles = Group.objects.create(name="The Beatles")
  >>> m1 = Membership(person=ringo, group=beatles,
  ...     date_joined=date(1962, 8, 16),
  ...     invite_reason="Needed a new drummer.")
  >>> m1.save()
  >>> beatles.members.all()
  <QuerySet [<Person: Ringo Starr>]>
  >>> ringo.group_set.all()
  <QuerySet [<Group: The Beatles>]>
  >>> m2 = Membership.objects.create(person=paul, group=beatles,
  ...     date_joined=date(1960, 8, 1),
  ...     invite_reason="Wanted to form a band.")
  >>> beatles.members.all()
  <QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>]>
  

  不同于一般的多对多字段，你不能使用add()，create()或者set()创建关系：

  >>> # 下面的语句不会生效
  >>> beatles.members.add(john)
  >>> beatles.members.create(name="George Harrison")
  >>> beatles.members.set([john, paul, ringo, george])
  

  为什么？您不能只在Person和Group之间创建关系 - 您需要指定Membership模型所需关系的所有细节 。简单的add，create调用不提供一种方式来指定这个额外的细节。因此，对于使用中间模型的多对多关系，它们被禁用。创建此类关系的唯一方法是创建中间模型的实例。

  由于类似的原因remove()方法也被禁用。例如，如果中间模型中不强制在(model1, model2)上的唯一性，remove()将不能提供足够的信息，以使得中间模型实例应被删除：

  >>> Membership.objects.create(person=ringo, group=beatles,
  ...     date_joined=date(1968, 9, 4),
  ...     invite_reason="You've been gone for a month and we miss you.")
  >>> beatles.members.all()
  <QuerySet [<Person: Ringo Starr>, <Person: Paul McCartney>, <Person: Ringo Starr>]>
  
  >>> #  下面的语句不会生效，因为没有指出哪个membership 要被删除 
  >>> beatles.members.remove(ringo)
  

  但是，clear() 方法可用于删除一个实例的所有多对多关系：

  >>> # Beatles have broken up
  >>> beatles.members.clear()
  >>> # Note that this deletes the intermediate model instances
  >>> Membership.objects.all()
  <QuerySet []>
  

  通过创建中间模型的实例建立多对多关系后，您可以发出查询。与普通的多对多关系一样，您可以使用多对多相关模型的属性进行查询：

  # Find all the groups with a member whose name starts with 'Paul'
  >>> Group.objects.filter(members__name__startswith='Paul')
  <QuerySet [<Group: The Beatles>]>
  

  在使用中间模型时，您还可以查询其属性：

  如果您需要访问会员资格，可以直接查询Membership模型：

  # Find all the members of the Beatles that joined after 1 Jan 1961
  >>> Person.objects.filter(
  ...     group__name='The Beatles',
  ...     membership__date_joined__gt=date(1961,1,1))
  <QuerySet [<Person: Ringo Starr]>
  

  访问同一信息的另一种方式是通过查询一个 Person对象的 多对多反向关系 ：

  >>> ringos_membership = ringo.membership_set.get(group=beatles)
  >>> ringos_membership.date_joined
  datetime.date(1962, 8, 16)
  >>> ringos_membership.invite_reason
  'Needed a new drummer.'
  

  3.5.3 一对一

  要定义一对一的关系，请使用OneToOneField。您可以像使用任何其他Field类型一样使用它 ：将其包含为模型的类属性。

  当对象以某种方式“扩展”另一个对象时，这对于对象的主键最有用。

  OneToOneField 需要一个必须的参数：与模型相关的类的名字。

  例如，如果您正在构建“place(地点)”数据库，您将在数据库中构建非常完整的内容，例如地址，电话号码等。然后，如果你想在这些地点建立一个餐馆数据库，而不是在Restaurant模型中复制并重复这些字段，你可以让Restaurant有一个OneToOneField字段并关联到Place（因为一个餐馆“是一个”地点";事实上，处理这通常使用 继承，它涉及隐式的一对一关系）。

  与ForeignKey相同，可以定义递归关系并且可以对尚未定义的模型进行引用。

  参见
  有关完整示例，请参阅一对一关系模型示例。

  OneToOneField字段也接受可选的 parent_link参数。

  OneToOneField类在模型中会自动变成主键。这不再有效（尽管你可以手动传入primary_key参数）。因此，现在单个模型上可以具有多个OneToOneField在类型的字段 。

  3.6 跨app引用模型

  将模型与另一个应用程序中的模型相关联是完全可以的。为此，请在定义模型的文件顶部导入相关模型。然后，只需在需要的地方引用其他模型类。例如：

  from django.db import models
  from geography.models import ZipCode
  
  class Restaurant(models.Model):
      # ...
      zip_code = models.ForeignKey(
          ZipCode,
          on_delete=models.SET_NULL,
          blank=True,
          null=True,
      )
  

  3.7 字段名称限制

  Django对模型字段名称只有两个限制：

  • 字段名称不能是Python保留字，因为这会导致Python语法错误。例如：

  class Example(models.Model):
      pass = models.IntegerField() # 'pass' is a reserved word!
  

  • 由于Django的查询查找语法的工作方式，字段名称不能在一行中包含多个下划线。例如：

  class Example(models.Model):
      foo__bar = models.IntegerField() # 'foo__bar' has two underscores!
  

  但是，这些限制可以解决，因为您的字段名称不一定必须与您的数据库列名称匹配。请参阅 db_column 选项。

  SQL保留字（例如join，where或select）被允许作为模型字段名称，因为Django会转义每个基础SQL查询中的所有数据库表名和列名。它使用特定数据库引擎的引用语法。

  3.8 自定义字段类型

  如果其中一个现有模型字段不能用于满足您的目的，或者您希望利用一些不太常见的数据库列类型，则可以创建自己的字段类。自定义模型字段 提供了创建自己的字段的全部内容。

  4.Meta选项

  在模型类内定义一个Meta类，可以为模型类提供元数据，如下所示：

  from django.db import models
  
  class Ox(models.Model):
      horn_length = models.IntegerField()
  
      class Meta:
          ordering = ["horn_length"]
          verbose_name_plural = "oxen"
  

  模型元数据是“任何不是字段的东西”，例如排序选项（ordering），数据库表名（db_table）或人类可读的单数和复数名称（verbose_name和 verbose_name_plural）。class Meta是一个可选项。

  Meta所有可能选项的完整列表可以在Meta选项中找到。

  5.模型属性

  objects
  模型最重要的属性是 Manager。它是为Django模型提供数据库查询操作的接口，用于 从数据库中检索实例。如果没有自定义Manager，则默认名称为 objects。Managers只能通过模型​​类访问，而不能通过模型​​实例访问。

  6.模型方法

  在模型上自定义方法，以向对象添加自定义“行级”功能。虽然Manager方法旨在执行“表内"的事情，但模型方法可以作用于特定的模型实例。

  这是将业务逻辑保存在一个地方的有价值的技术 - 模型。

  例如，此模型有一些自定义方法：

  from django.db import models
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
      birth_date = models.DateField()
  
      def baby_boomer_status(self):
          "Returns the person's baby-boomer status."
          import datetime
          if self.birth_date < datetime.date(1945, 8, 1):
              return "Pre-boomer"
          elif self.birth_date < datetime.date(1965, 1, 1):
              return "Baby boomer"
          else:
              return "Post-boomer"
  
      @property
      def full_name(self):
          "Returns the person's full name."
          return '%s %s' % (self.first_name, self.last_name)
  

  此示例中的最后一个方法是 property (也就是python中的property方法)。

  model instance reference中给出了 模型类自动添加的方法 的完整列表。您可以覆盖其中的大多数 - 请参阅下面的 覆盖预定义模型方法 - 但有几个方法您几乎总是要自定义：

  __str__()
  Python“魔术方法”，返回任何对象的字符串表示形式。这是Python和Django在模型实例需要被强制并显示为纯字符串时将使用的内容。最值得注意的是，当您在交互式控制台或管理员中显示对象时会发生这种情况。

  你总是想要定义这个方法; 因为默认的此方法没什么实质性的作用。

  get_absolute_url()
  这告诉Django如何计算对象的URL。Django在其admin管理界面中使用它，并且只需要它找出对象的URL。

  具有唯一标识它的URL的任何对象都应定义此方法。

  6.1 覆盖预定义模型方法

  还有另一组 模型方法，它们封装了一些您想要自定义的数据库行为。特别是你经常想改变save()和 delete()的工作方式。

  您可以自由地覆盖这些方法（以及任何其他模型方法）来改变行为。

  用于覆盖内置方法的经典用例是，如果您希望在save对象时发生某些事情。例如（参见 save()方法接受的参数的文档）：

  from django.db import models
  
  class Blog(models.Model):
      name = models.CharField(max_length=100)
      tagline = models.TextField()
  
      def save(self, *args, **kwargs):
          do_something()
          super().save(*args, **kwargs)  # Call the "real" save() method.
          do_something_else()
  

  您还可以阻止保存：

  from django.db import models
  
  class Blog(models.Model):
      name = models.CharField(max_length=100)
      tagline = models.TextField()
  
      def save(self, *args, **kwargs):
          if self.name == "Yoko Ono's blog":
              return # Yoko shall never have her own blog!
          else:
              super().save(*args, **kwargs)  # Call the "real" save() method.
  

  重要的是要记住调用父类方法super().save(*args, **kwargs) ， 以确保对象仍然保存到数据库中。如果您忘记调用超类方法，则不会发生默认行为，也不会触及数据库。

  传递可以传递给模型方法的参数也很重要，那就是*args和**kwargs的作用。Django将不时扩展内置模型方法的功能，增加新的参数。如果在方法定义中使用*args, **kwargs，则可以保证代码在添加时自动支持这些参数。

  在批量操作中不会调用重写的模型方法
  使用QuerySet在批量操作中删除对象或者级联删除的时候，对象的delete()方法不一定要调用。为确保执行自定义delete()方法，您可以使用 pre_delete或者post_delete信号。
  不幸的是，在批量操作中没办法创建或更新对象，因为不会调用save()， pre_save和 post_save。

  6.2 执行自定义SQL

  另一种常见模式是在模型方法和模块级方法中编写自定义SQL语句。有关使用原始SQL的更多详细信息，请参阅有关使用原始SQL的文档。

  7.模型继承

  在 Django 中模型继承与在 Python 中普通类继承的工作方式几乎完全相同, 但也仍应遵循本页开头的内容. 这意味着其基类应该继承django.db.models.Model.

  您必须做出的唯一决定是您希望父模型本身是模型（有自己的数据库表），还是父类只保存了一些通用信息，且子模型可见。

  Django中有三种可能的继承方式。

  • 通常，您只想使用父类来保存您不希望为每个子模型键入的信息。这个类不会被单独使用，所以 抽象基类 就是你所追求的。
  • 如果你是现有模型的子类（可能是完全来自另一个应用程序的模型），并希望每个模型都有自己的数据库表，那么 多表继承 是最佳选择。
  • 最后，如果您只想修改模型的Python级行为，而不以任何方式更改模型字段，则可以使用 代理模型。

  7.1 抽象基类

  当您想要将一些公共信息放入许多其他模型时，抽象基类非常有用。你写你的基类，并在Meta类里放上abstract=True。然后，此模型将不用于创建任何数据库表。相反，当它用作其他模型的基类时，其字段将添加到子类的字段中。

  一个例子：

  from django.db import models
  
  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)
  

  Student模型将有三个属性：name，age和 home_group。CommonInfo模型不能用作普通的Django模型，因为它是一个抽象基类。它不生成数据库表或具有管理器，并且无法直接实例化或保存。

  从抽象基类继承的字段可以使用其他字段或值覆盖，也可以使用None来删除。

  对于许多用途，这种类型的模型继承将完全符合您的要求。它提供了一种在Python级别分解公共信息的方法，同时仍然只在数据库级别为每个子模型创建一个数据库表。

  7.1.1 Meta继承

  当创建抽象基类时，基类中的内部类Meta被声明为一个属性。如果子类没有声明自己的Meta 类，它将继承父类的Meta。如果孩子想要扩展父类的Meta类，它可以将其子类化。例如：

  from django.db import models
  
  class CommonInfo(models.Model):
      # ...
      class Meta:
          abstract = True
          ordering = ['name']
  
  class Student(CommonInfo):
      # ...
      class Meta(CommonInfo.Meta):
          db_table = 'student_info'
  

  Django确实对抽象基类的Meta类进行了一次调整：在安装Meta属性之前，它设置了abstract=False。这意味着抽象基类的子类本身不会自动成为抽象类。当然，您可以创建一个继承自另一个抽象基类的抽象基类。您只需要记住每次都明确设置abstract=True就可以了。

  在抽象基类的Meta类中包含一些属性是不会生效的。例如，包含db_table意味着所有子类（未指定自己的Meta）将使用相同的数据库表，这几乎肯定不是您想要的。

  7.1.2 小心related_name和related_query_name

  如果你在ForeignKey 或 ManyToManyField中使用了related_name或 related_query_name属性，则必须始终为该字段指定唯一的反向名称和查询名称。这通常会导致抽象基类出现问题，因为此类中的字段包含在每个子类中，每次都具有完全相同的属性值（包括 related_name和 related_query_name）。

  若要解决此问题，当您在抽象基类使用 related_name或 related_query_name时，值的一部分应该是'%(app_label)s'和 '%(class)s'。

  • '%(class)s' 被替换为使用该字段的子类的小写名称。
  • '%(app_label)s'由包含在子类在内的应用程序的小写名称替换。每个安装的应用程序名称必须是唯一的，并且每个应用程序中的模型类名称也必须是唯一的，因此生成的名称最终会有所不同。

  例如，给定一个应用程序common/models.py：

  from django.db import models
  
  class Base(models.Model):
      m2m = models.ManyToManyField(
          OtherModel,
          related_name="%(app_label)s_%(class)s_related",
          related_query_name="%(app_label)s_%(class)ss",
      )
  
      class Meta:
          abstract = True
  
  class ChildA(Base):
      pass
  
  class ChildB(Base):
      pass
  

  与另一个应用程序rare/models.py：

  from common.models import Base
  
  class ChildB(Base):
      pass
  

  common.ChildA.m2m字段的反向名称将是common_childa_related，反向查询名称将是common_childas。common.ChildB.m2m字段的反向名称将是 common_childb_related，反向查询名称将是common_childbs。最后，rare.ChildB.m2m字段的反向名称将是rare_childb_related，反向查询名称是 rare_childbs。由你如何使用'%(class)s'和 '%(app_label)s'部分来构造你的相关名称或相关的查询名称，但如果你忘记使用它，Django会在你执行系统检查（或运行migrate）时引发错误。

  如果没有为抽象基类中的字段指定related_name 属性，则默认反向名称将是子类的名称_set，就像通常直接在子类上声明字段一样。例如，在上面的代码中，如果省略了related_name 属性，对于ChildA来说，m2m字段的反向名称将是 childa_set，对于ChildB来说是childb_set。

  7.2 多表继承

  Django支持的第二种模型继承是当层次结构中的每个模型都是模型本身时。每个模型对应于自己的数据库表，可以单独查询和创建。继承关系引入子模型与其每个父模型之间的链接（通过自动创建OneToOneField）。例如：

  from django.db import models
  
  class Place(models.Model):
      name = models.CharField(max_length=50)
      address = models.CharField(max_length=80)
  
  class Restaurant(Place):
      serves_hot_dogs = models.BooleanField(default=False)
      serves_pizza = models.BooleanField(default=False)
  

  Place表中的字段在Restaurant表中也可以用到，尽管两者的数据分在不同的表中存放：

  >>> Place.objects.filter(name="Bob's Cafe")
  >>> Restaurant.objects.filter(name="Bob's Cafe")
  

  ---

  译者注: 自己写了个例子有助于理解
  （1）在place表中插入一条记录name=Bob's Cafe ,address=china-z
  （2）在restaurant表中插入一条记录name=zb's CCx, address=china-ccb
  在两张表中分别插入一条记录，结果如下
  
  （3）可以看到，父类中的数据保存在父表中，子类中通过一个plact_ptr_id来引用父表中的id属性。
  （4）查看restaurant表的定义
  
  可以看到 Django为子类表自动生成了一个外键引用，指向父类，这也解释了开头说的 继承关系引入子模型与其每个父模型之间的链接（通过自动创建OneToOneField）

  ---

  如果你有一个Restaurant对象实例，你可以使用小写的模型名称从 Place对象得到Restaurant对象：

  >>> p = Place.objects.get(id=12)
  # If p is a Restaurant object, this will give the child class:
  >>> p.restaurant
  <Restaurant: ...>
  

  但是，如果在上面的示例中p不是一个Restaurant实例（它已直接创建为Place对象或是其他父级类），则引用p.restaurant会引发Restaurant.DoesNotExist 异常。

  在Restaurant中自动创建的OneToOneField ，它链接到Place看起来像这样：

  place_ptr = models.OneToOneField(
      Place, on_delete=models.CASCADE,
      parent_link=True,
  )
  

  你可以按照上面的例子在Restaurant中重写这个一对一关系，并且指定parent_link=True 属性。

  7.2.1 Meta和多表继承

  在多表继承情况下，子类从其父类继承的Meta类是没有意义的。所有的Meta选项都已经应用于父类，并且再次应用它们通常只会导致矛盾的行为（这与基类本身不存在的抽象基类情况形成对比）。

  因此，子模型无法访问其父级的Meta类。但是，有一些特殊的情况：如果子类没有指定 ordering属性或 get_latest_by属性，它将从其父类继承它们。

  如果父类有一个ordering属性而你不希望孩子有任何自然顺序，你可以明确地禁用它：

  class ChildModel(ParentModel):
      # ...
      class Meta:
          # Remove parent's ordering effect
          ordering = []
  

  7.2.2 继承和反向关系

  因为多表继承使用隐式 OneToOneField链接子项和父项，所以可以从父类到子类，如上例所示。但是，这会占用ForeignKey和ManyToManyField中默认的related_name值 。如果要将这些类型的关系放在子类上，则 必须 在每个此类字段上指定related_name属性。如果您忘记了，Django将引发验证错误。

  例如，再次使用上面的Place类，让我们创建另一个子类，其中包含ManyToManyField：

  class Supplier(Place):
      customers = models.ManyToManyField(Place)
  

  这会导致错误：

  Reverse query name for 'Supplier.customers' clashes with reverse query
  name for 'Supplier.place_ptr'.
  
  HINT: Add or change a related_name argument to the definition for
  'Supplier.customers' or 'Supplier.place_ptr'.
  

  添加related_name到customers字段将解决错误：models.ManyToManyField(Place, related_name='provider')

  7.2.3 指定 parent_link 字段

  如上所述，Django将自动创建一个 OneToOneField，将您的子类链接回任何非抽象父模型。如果要控制链接回父级的属性的名称，可以创建自己的属性OneToOneField并设置 parent_link=True 为指示您的字段是返回父类的链接。

  7.3 代理模型

  使用多表继承时，会为模型的每个子类创建一个新的数据库表。这通常是所需的行为，因为子类需要一个位置来存储基类上不存在的任何其他数据字段。但是，有时您只想更改模型的Python行为 - 可能更改默认管理器或添加新方法。

  这就是代理模型继承的用途：为原始模型创建代理。您可以创建，删除和更新代理模型的实例，并且将保存所有数据，就像使用原始（非代理）模型一样。不同之处在于您可以更改代理中的默认模型排序或默认管理器等内容，而无需更改原始内容。

  代理模型声明为普通模型。你通过设置模型的Meta类的proxy属性为True，告诉Django它是一个代理模型。

  例如，假设您要向Person模型添加方法。你可以这样做：

  from django.db import models
  
  class Person(models.Model):
      first_name = models.CharField(max_length=30)
      last_name = models.CharField(max_length=30)
  
  class MyPerson(Person):
      class Meta:
          proxy = True
  
      def do_something(self):
          # ...
          pass
  

  MyPerson类和父类Person操作数据库中的同一个表。特别是，任何新的实例Person也可以通过MyPerson来得到，反之亦然：

  >>> p = Person.objects.create(first_name="foobar")
  >>> MyPerson.objects.get(first_name="foobar")
  <MyPerson: foobar>
  

  你仍然可以使用一个代理模型来定义模型的默认排序方法。你也许不会想一直对“Person”进行排序，但是通常情况下用代理模型根据“last_name”属性进行排序。这很简单:

  class OrderedPerson(Person):
      class Meta:
          ordering = ["last_name"]
          proxy = True
  

  正常的Person查询将是无序的，OrderedPerson查询将按last_name的顺序排序。

  译者投下一个例子
  

  代理模型继承“Meta”属性：和普通模型使用同样的方法

  7.3.1 QuerySet仍然返回被请求的模型

  每当你查询MyPerson对象时，就是返回了Person对象。一个queryset返回这些Person类型的对象。代理对象的重点是依赖于原始代码，Person将使用这些代码，并且您自己的代码可以使用您包含的扩展（无论如何其他代码都不依赖）。它不是Person用你自己创造的东西替换任何地方（或任何其他）模型的方法。（翻译不太准）

  7.3.2 基类限制

  一个代理模型必须仅能继承一个非抽象模型类。你不能继承多个非抽象模型类，因为代理模型无法提供不同数据表的任何行间连接。一个代理模型可以继承任意数量的抽象模型类，假如他们没有定义任何的模型字段。一个代理模型也可以继承任意数量的代理模型，只需他们共享同一个非抽象父类。

  7.3.3 代理模型管理器

  如果未在代理模型上指定任何模型管理器，它将从其父类模型继承管理器。如果您在代理模型上定义管理器，它将成为默认管理器，尽管在父类上定义的任何管理器仍然可用。

  继续上面的示例，您可以更改查询Person模型时使用的默认管理器，如下所示：

  from django.db import models
  
  class NewManager(models.Manager):
      # ...
      pass
  
  class MyPerson(Person):
      objects = NewManager()
  
      class Meta:
          proxy = True
  

  如果要在不更换默认管理器的情况下向代理添加新管理器，可以使用自定义管理器文档中描述的技术：创建包含新管理器的基类，并在主基类之后继承：

  # 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
  

  译者注：此处投下一个使用实例
  
  通常情况下，你可能不需要这么做。然而，你需要的时候，这也是可以的。

  7.3.4 代理继承和非托管模型之间的差异

  代理模型继承可能看起来与非托管模型（在模型类的Meta类中使用managed属性）非常相似。

  通过仔细设置Meta.db_table您可以创建一个非托管模型，该模型可以隐藏现有模型并为其添加Python方法。但是，如果您进行任何更改，则需要保持两个副本同步，这将是非常重复和脆弱的。

  另一方面，代理模型的行为与它们所代理的模型完全相同。它们始终与父模型同步，因为它们直接继承其字段和管理器。

  一般规则是：

  • 如果要镜像现有模型或数据库表，并且不想要所有原始数据库表列，请使用Meta.managed=False。该选项通常用于建模不受Django控制的数据库视图和表。
  • 如果您想要更改模型的Python行为，但保留与原始字段相同的字段，请使用Meta.proxy=True。这进行了设置，以便在保存数据时代理模型是原始模型的存储结构的精确副本。

  8. 多重继承

  正如Python的子类化一样，Django模型可以从多个父模型继承。请记住，正常的Python名称解析规则适用。第一个有特定名称（例如Meta）的基类将是使用的基类; 例如，这意味着如果多个父类都包含一个Meta类，则只会使用第一个类，而将忽略所有其他类。

  通常，您不需要从多个父类继承。主要的使用场景是“混入”类：向每个继承混合类的类添加特定的额外字段或方法。尽量使您的继承层次结构尽可能简单明了，这样您就不必费力去找出特定信息来自哪里。

  请注意，从都具有id主键字段的多个模型继承将引发错误。要正确使用多重继承，可以在基本模型中显示地指定AutoField字段：

  class Article(models.Model):
      article_id = models.AutoField(primary_key=True)
      ...
  
  class Book(models.Model):
      book_id = models.AutoField(primary_key=True)
      ...
  
  class BookReview(Book, Article):
      pass
  

  或者使用让共同的祖先来保持AutoField字段。这需要使用OneToOneField从每个父模型到共同祖先的显式来避免子项自动生成和继承的字段之间的冲突：

  class Piece(models.Model):
      pass
  
  class Article(Piece):
      article_piece = models.OneToOneField(Piece, on_delete=models.CASCADE, parent_link=True)
      ...
  
  class Book(Piece):
      book_piece = models.OneToOneField(Piece, on_delete=models.CASCADE, parent_link=True)
      ...
  
  class BookReview(Book, Article):
      pass
  

  9.不允许字段名称“隐藏”

  在普通的Python类继承中，子类允许覆盖父类的任何属性。在Django中，模型字段通常不允许这样做。如果非抽象模型基类具有一个author字段，则无法创建另一个author模型字段，子类中也不能有author字段。

  此限制不适用于从抽象模型继承的模型字段。这些字段可以用另一个字段或值覆盖，或者通过设置field_name = None来删除。

  警告
  模型管理器继承自抽象基类。覆盖父类字段 (此字段由继承的 Manager引用），可能会导致细微的错误。请参阅 自定义管理器和模型继承。

  注解
  某些字段在模型中定义额外的属性，例如 ForeignKey定义了一个额外的属性 _id附加到字段名称，以及related_name和 related_query_name属性。
  除非更改或删除定义它的字段以使其不再定义额外属性，否则不能覆盖这些额外属性。

  在父模型中覆盖字段会导致诸如初始化新实例（在Model.__init__中指定正在初始化哪个字段）和序列化等方面的困难 。这些是普通Python类继承不必以完全相同的方式处理的特性，因此Django模型继承和Python类继承之间的区别不是随意的。

  此限制仅适用于作为Field实例的属性 。如果您愿意，可以覆盖普通的Python属性。它也只适用于Python看到的属性名称：如果您手动指定数据库列名，则可以在子表和祖先模型中出现相同的列名，以用于多表继承（它们是列在两个不同的数据库表中）。

  如果你覆盖任何祖先模型中的任何模型字段，Django将引发一个FieldError。

  10.在包中组织模型

  manage.py startapp命令创建包含models.py文件的应用程序结构。如果您有许多模型，则在分开的文件中组织它们可能很有用。

  为此，请创建一个models包。删除models.py并创建一个myapp/models/文件夹包含__init__.py文件和存储模型的文件。您必须在__init__.py文件中导入模型。

  例如，如果你在models 目录中有organic.py和synthetic.py：

  # myapp/models/__init__.py
  from .organic import Person
  from .synthetic import Robot
  

  显式导入每个模型而不是使用from .models import *，这样做的好处是不会使命名空间混乱，使代码更具可读性以及保持代码分析工具更易理解。

  你可能感兴趣的:(Django,2.1,文档,翻译)

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Shell、Bash、Zsh这都是啥啊 小白码上飞 bashlinux开发语言
    Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • 基于Python给出的PDF文档转Markdown文档的方法 程序媛了了 pythonpdf开发语言
    注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
  • 可以赚钱的app，你们都在用哪些？ 配音新手圈
    1.七猫免费小说2.有柿3.番茄小说兼职副业推荐公众号，配音新手圈，声优配音圈，新配音兼职圈，配音就业圈，鼎音副业，有声新手圈，每天更新各种远程工作与在线兼职，职位包括：写手、程序开发、剪辑、设计、翻译、配音、无门槛、插画、翻译、等等。。。每日更新兼职。4.速读免费小说5.得间免费小说6.快手7.快手极速8.抖音火山版（可提0.2，可能我懒赚的慢，但真不推荐）9.拼多多10.淘宝11.点淘12.美
  • 2020-8-19晨间日记：看过的电影 盐大虾
    今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 简单说说关于shell中zsh和bash的选择 秋刀prince MacOS小猿们的开发日常bash
    希望文章能给到你启发和灵感～如果觉得文章对你有帮助的话，点赞+关注+收藏支持一下博主吧～阅读指南开篇说明一、基础环境说明1.1硬件环境1.2软件环境二、什么是shell、bash、zsh?2.1bash2.2zsh三、选择Bash还是Zsh？四、一些常见问题开篇说明本篇主要简单说明一下，shell中bash和zsh的区别和选择；我们经常会把这两个搞混，不知道什么时候用哪一个，以及怎么使用；一、基础
  • Vue( ElementUI入门、vue-cli安装) m0_l5z elementuivue.js
    一.ElementUI入门目录：1.ElementUI入门1.1ElementUI简介1.2Vue+ElementUI安装1.3开发示例2.搭建nodejs环境2.1nodejs介绍2.2npm是什么2.3nodejs环境搭建2.3.1下载2.3.2解压2.3.3配置环境变量2.3.4配置npm全局模块路径和cache默认安装位置2.3.5修改npm镜像提高下载速度2.3.6验证安装结果3.运行n
  • 入门MySQL——查询语法练习 K_un
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
  • 免费的GPT可在线直接使用（一键收藏） kkai人工智能 gpt
    1、LuminAI（https://kk.zlrxjh.top）LuminAI标志着一款融合了星辰大数据模型与文脉深度模型的先进知识增强型语言处理系统，旨在自然语言处理（NLP）的技术开发领域发光发热。此系统展现了卓越的语义把握与内容生成能力，轻松驾驭多样化的自然语言处理任务。VisionAI在NLP界的应用领域广泛，能够胜任从机器翻译、文本概要撰写、情绪分析到问答等众多任务。通过对大量文本数据的
  • 【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作 Lossya ui自动化测试工具自动化测试appium
    引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • Ubuntu18.04 Docker部署Kinship(Django)项目过程 Dante617
    1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
  • APQP，ASPICE，敏捷，功能安全，预期安全，这些汽车行业的一堆标准 二大宝贝 安全架构
    前言APQP,ASPICE,敏捷，功能安全，预期安全，PMP，PRICE2汽车行业的有这样一堆标准。我是半路出家来到汽车行业做项目经理的，对几个标准的感觉是，看了文档和各种解析之后还是一头雾水，不知道到底说了个啥，别人问我还是一脸懵逼。APQP（TS16949的最重要工具），ASPICE（软件）这些是质量标准，是优化整个公司体系的，但这套体系对项目管理有要求；敏捷，PMP这些是项目管理的标准；项目
  • linux脚本sed替换变量,sed 命令中替换值为shell变量 诺坎普之约 linux脚本sed替换变量
    文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank
  • Regular Expression 正则表达式 Aimyon_36 DataDevelopment正则表达式redis数据库
    RegularExpression前言1.基本匹配2.元字符2.1点运算符.2.2字符集2.2.1否定字符集2.3重复次数2.3.1*号2.3.2+号2.3.3?号2.4{}号2.5(...)特征标群2.6|或运算符2.7转码特殊字符2.8锚点2.8.1^号2.8.2$号3.简写字符集4.零宽度断言（前后预查）4.1?=...正先行断言4.2?!...负先行断言4.3?Thefatcatsaton
  • 高仿一个echarts饼图 街角小林2
    开头饼图，很常见的一种图表，使用任何一个图表库都能轻松的渲染出来，但是，我司的交互想法千奇百怪，布局捉摸不透，本身饼图是没啥可变的，但是配套的图例千变万化，翻遍ECharts配置文档都还原不出来，那么有两条路可以选，一是跟交互说实现不了，说服交互按图表库的布局来，但是一般交互可能会对你灵魂拷问，为什么别人都能做出来，你做不出来？所以我选第二种，自己做一个得了。用canvas实现一个饼图很简单，所以
  • ArcGIS Pro SDK （十四）地图探索 5 时间与动画 WineMonk ArcGISProSDKarcgisarcgisprosdkgisc#
    ArcGISProSDK（十四）地图探索5时间与动画文章目录ArcGISProSDK（十四）地图探索5时间与动画1时间1.1时间提前1个月1.2禁用地图中的时间。2动画2.1设置动画长度2.2缩放动画2.3相机关键帧2.4插值相机2.5插值时间2.6插值范围2.7创建摄像机关键帧2.8创建时间关键帧2.9创建范围关键帧2.10创建图层关键帧环境：VisualStudio2022+.NET6+Arc
  • 浅评《记忆像铁轨一样长》中的修辞手法 后会定无期
    《记忆像铁轨一样长》是已逝世的余光中先生在一九八四年创作的一篇散文，后成为其代表作之一。余光中先生作为著名的作家、诗人和翻译家，素有文坛“璀璨五彩笔”、“诗文双绝”和“诗坛最后的守夜人”等美誉。《记忆像铁轨一样长》这篇散文也继承了作者一贯的风格，全文语言优美隽永，结构清晰紧凑，节奏张弛有度，想象天马行空，感情细腻真挚。其中运用了大量的修辞手法，或新颖巧妙，或生动有趣，用词准确灵活，给读者留下了深刻
  • Vue3 vant组件库自动导入 不叫虎子 Vuevue.js前端javascript前端框架typescript
    实现：完整使用vant组件库文档安装：#Vue3项目，安装最新版Vantnpmivant#通过yarn安装yarnaddvant#通过pnpm安装pnpmaddvant【一】按需引入：https://vant-contrib.gitee.io/vant/#/zh-CN/quickstart#fang-fa-er.-an-xu-yin-ru-zu-jian-yang-shi【二】批量引入在基于vit
  • 轻量级模型解读——轻量transformer系列 lishanlu136 #图像分类轻量级模型transformer图像分类
    先占坑，持续更新。。。文章目录1、DeiT2、ConViT3、Mobile-Former4、MobileViTTransformer是2017谷歌提出的一篇论文，最早应用于NLP领域的机器翻译工作，Transformer解读，但随着2020年DETR和ViT的出现(DETR解读，ViT解读)，其在视觉领域的应用也如雨后春笋般渐渐出现，其特有的全局注意力机制给图像识别领域带来了重要参考。但是tran
  • 面向对象面向过程 3213213333332132 java
    面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
  • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
      openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
  • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
    向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
  • BaseDao 171815164 seda
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
  • Ant标签详解--Java命令 g21121 Java命令
            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
  • [简单]代码片段_电梯数字排列 53873039oycg 代码
           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
  • Hessian原理 云端月影 hessian原理
    Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
  • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
      在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
  • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
    (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
  • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
  • 强大的Mockito测试框架 bijian1013 mockito单元测试
    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
  • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
    /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
  • 【EhCache一】EhCache版Hello World bit1129 Hello world
    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
  • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
  • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
    angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
    public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
  • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
  • [机器智能与生物]研究生物智能的问题 comsci 生物
          我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
  • 获取Android Device的信息 dai_lm android
    String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
    long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
  • macvim的使用实战 dcj3sjt126com macvim
    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
  • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
    java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
  • Spring Cache注解+Memcached hanqunfeng springmemcached
    Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
  • apache commons io包快速入门 jackyrong apache commons
    原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
  • 如何学习编程 lampcy java编程C++c
    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
    1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
  • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
  • Hibernate入门 tntxia Hibernate
      前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
  • Math类 xiaoxing598 Math
    一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round
  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.